Shell Scripts Uteis

quinta-feira, 5 de maio de 2016

ShellScript para ajudar na configuração do sysctl.conf

ShellScript para ajudar na configuração do sysctl.conf para maquinas com no máximo 8GB !

#!/bin/bash
echo "Enter RAM ex: 1 for 1GB 2 for 2GB 4 for 4GB 8 for 8GB"
read RAM
N1=`echo "256 * $RAM" | bc`
N2=`echo "1024 * $RAM" | bc`
N3=`echo "1073741824 * $RAM" | bc`
N4=`getconf PAGESIZE`
N5=`echo "$N3 / $N4" | bc`

echo "kernel.sem = 250 256000 32 $N1"
echo "kernel.shmall = $N5"
echo "kernel.shmmax = $N3"
echo "kernel.shmmni = $N1"
echo "kernel.msgmni = $N2"
echo "kernel.msgmax = 65535"
echo "kernel.msgmnb = 65535"
echo vm.swappiness=0
echo vm.overcommit_memory=0
echo kernel.randomize_va_space=0

terça-feira, 6 de outubro de 2015

Lição 4 - Programação de Jogos em ShellScript

Antes de começar gostaria de dizer que fiquei impressionado com os games que a galera me mostrou feitas com base nas primeiras liçoes e muita pesquisa. e mais uma vez desculpem por deixar o blog criando teia de aranha...

Essa lição vai falar de ARMAS !!! vamos começar com algumas rotinas de tiro e espada.

Além disso melhorias nos códigos para diminuir bugs do que foi mostrado até aqui.

Atenção nos comentários em laranja !

Arquivo licao4.sh

#!/bin/bash
setterm -cursor off
# Adicionei esse trap para desfazer as alterações no final da execução.
trap "stty $(stty -g);setterm -cursor on" EXIT
#Esse stty serve para não imprimir na tela o que é digitado, também adicionei o time para limitar o tempo de leitura do teclado.
stty -echo time 2 || exit $?
clear
echo "Use a w s d para movimentar e j para atirar k para usar espada"
x=0
y=1
a=0
#Adicionei as variáveis t, e i para controle das armas
t=0
i=0

#Na variável inimigo coloquei um numero que será a localização do inimigo, em seguida imprimi o inimigo e o personagem na tela.
inimigo="1030"
tput cup 1 0
echo -n "o"
tput cup `echo $inimigo | cut -c1-2` `echo $inimigo | cut -c3-4`
echo -n "X"

until [ $a = q ];do
read -s -n 1 a
######## Leitura do Teclado ####
#Adicionei a pequena função limpa, para não ficar utilizando o comando clear, deixando os frames menos bugados, por conta dessa mudança tive que adicionar aquele stty para não ficar sujando a tela com caracteres conforme os botões são pressionados. profissionalmente isso se chama buffering ou algo assim...
limpa(){
tput cup $y $x
echo -n " "
}

if [ $a = a ];then
#sempre que eu aperto o botão de movimento primeiramente ele limpa o vulgo "buffer"...
limpa
let "x = x - 1"
fi
if [ $a = d ];then
limpa
let "x = x + 1"
fi
if [ $a = w ];then
limpa
let "y = y - 1"
fi
if [ $a = s ];then
limpa
let "y = y + 1"
fi
#Aqui temos o botão k para uso da espada... muita calma nessa hora reparem que pego o valor de x, somo 1 para exibir a espada na frente do personagem "o", além disso coloquei a localização do inimigo na variável i, subtraindo 1 para melhorar a observação do evento...
if [ $a = k ];then
let "t = $x + 1"
let "i = $inimigo - 1"
#Se a espada atingir o inimigo, eu imprimo o inimigo com metade da espada no peito... tem que ter imaginação.... espero 2 segundos e termino a execução...
if [ "$y$t" -eq $i ];then
tput cup $y $t
echo -n "+X"
tput cup 1 1
echo "Voce Matou o Inimigo na Espada! Ele Morreu !"
sleep 2
a=q
#Se não acertar imprimo a espada inteira na frente do personagem, e espero 0.5 segundos imprimo o buffer em branco no mesmo lugar... seria ele demorando um pouco para guardar a espada pq ela é pesada...
else
tput cup $y $t
echo -n "+-"
sleep 0.5
tput cup $y $t
echo -n " "
fi
fi
#O botão j é uma arma que atira, começa com o mesmo principio da espada mas o tiro tem que ir longe então usei mais um until para fazer ele correr na tela até certo ponto ou até atingir o inimigo.
if [ $a = j ];then
let "t = $x + 1"
let "i = $inimigo - 1"
#Tiro correndo na tela reparem que imprimindo " -" vou apagando o anterior e fazendo ele avançar
until [ $t -ge 100 ] || [ "$y$t" -eq $i ];do
tput cup $y $t
echo -n " -"
#usei o sleep pois dependendo do super computadores atuais seria difícil ver o tiro....
sleep 0.003
let "t = t + 1"
done
#Esse if verifica se o tiro acertou o inimigo
if [ "$y$t" -eq $i ];then
tput cup 1 1
echo "Voce Matou o Inimigo na Bala! Ele Morreu !"
sleep 2
a=q
fi
#no final da rotina de tiro eu limpo a bala que sobrou na tela.
tput cup $y $t
echo -n " "
fi

################################

######## Inimigo ###############
#Coloquei esse exemplo de colisão com o inimigo se vc encostar nele vc morre.
if [ "$y$x" = "$inimigo" ];then
clear
setterm -cursor on
echo "VC encostou no inimigo ! voce morreu !"
echo FIM
exit
fi

################################

##### Movimento da Bolinha #####
#Mantive esse movimento mas também pode ser transformado em função e embarcado nos ifs de movimento.
tput cup $y $x
echo -n "o"
done
################################

clear
echo FIM

-----fim----

Atenção na próximas estarei começando a falar de scrolling, cores, movimento para os inimigos, listeners, e chegaremos em um pequeno game para jogar online via sessão de putty ou rede.

segunda-feira, 1 de dezembro de 2014

Bloqueando Spam List-Unsubscribe no header_checks

Estava vendo que varios spams vem com a tag List-Unsubscribe em seu header, e decidi colocar isso no headers_check, como todos de inicio usei a seguinte configuração:

/^List-Unsubscribe:/ DISCARD SPAM

E logicamente, em algumas semanas percebi que algumas listas de parceiros estavam sendo bloqueadas...
Comecei a pesquisa e realmente não há whitelist para o header_checks.

A saída foi utilizar uma configuração condição...

Como não encontrei nada na internet e tive que me virar para fazer, perdendo um tempinho considerável estou compartilhando aqui no meu blog abandonado :)

/etc/postfix/spamheadercheck
if /^List-Unsubscribe:/
!/.*(parceiro.com|paceiro2.com|parceiro3.com)/ DISCARD Spam
endif

/etc/postfix/main.cf
header_checks = pcre:/etc/postfix/spamheadercheck

Configurações para postfix !
Requer pcre
apt-get install postfix-pcre
*** vc pode colocar quantos parceiros quiser concatenando com |

Gostou ? Me pague uma cerveja ! ^_^

quarta-feira, 17 de outubro de 2012

Lição 3 - Programação de Jogos em ShellScript

A lição 3 também é interessante e fundamental. com o conceito da lição 3 já é possível sair por ai programando algum joguinho. tentei deixar esse assunto o mais simples possível. estarei falando de 2 coisas.

1) Mapas
2) Colisões

Mapas
Para um jogo fazer sucesso é interessante ter um mecanismo de mapa bem simples, que possa até possibilitar ao jogador criar um mapinha para se divertir. no meu exemplo o mapa pode ser desenhado em um simples arquivo de texto.

Colisões
Colisões são praticamente algo que fazem as coisas acontecerem. exemplo, bater o carrinho, levar um tiro, pegar algo, etc...

Vamos começar desenhando um mapa, crie um arquivo com o nome map.layout se quer usar outro nome ok... mas lembre-se disso na parte do código.

Desenhe o que quizer no mapa
Exemplo
nome do arquivo: map.layout
conteúdo:

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
X X
X X
X X
X X
X X
X X
X X
X X
X X
X X
X X
X X
X X
X X
X X
X X
X X
X X
X X
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

tudo que não for uma area em branco será considerado uma parede no joguinho

agora vamos ao código

nome do arquivo: game.sh

conteudo:

#!/bin/bash

setterm -cursor off

a=0

m=0

n=0

C=0

x=2

y=2

tput cup 0 0

cat map.layout

tput cup $y $x

echo -n "o"

until [ $a = q ];do

read -n 1 a

clear

cat map.layout

######## Leitura do Teclado ####

if [ $a = a ];then

let "m = x"

let "n = y + 1"

C=`cat map.layout | awk "NR == $n" | cut -c"$m"`

if [ -z $C ];then

let "x = x - 1"

if [ $a = d ];then

let "m = x + 2"

let "n = y + 1"

C=`cat map.layout | awk "NR == $n" | cut -c"$m"`

if [ -z $C ];then

let "x = x + 1"

if [ $a = w ];then

let "m = x + 1"

let "n = y"

C=`cat map.layout | awk "NR == $n" | cut -c"$m"`

if [ -z $C ];then

let "y = y - 1"

if [ $a = s ];then

let "m = x + 1"

let "n = y + 2"

C=`cat map.layout | awk "NR == $n" | cut -c"$m"`

if [ -z $C ];then

let "y = y + 1"

################################

tput cup $y $x

echo -n "o"

done

###############################

clear

setterm -cursor on

echo FIM

Comentários do código

x=2

y=2

#iniciei x e y com o valor 2, para nao começar com o player em uma parede.

tput cup 0 0

cat map.layout

#imprimi o mapa

if [ $a = a ];then

let "m = x"

let "n = y + 1"

C=`cat map.layout | awk "NR == $n" | cut -c"$m"`

if [ -z $C ];then

let "x = x - 1"

# A cada movimento eu verifico no mapa se tem alguma coisa naquela posição.

lembrando que o tput trabalha de 0 até ...

o awk e cut trabalham de 1 até ...

então usei o let com algumas variáveis para adaptar, mesmo assim ficou bem simples e leve.

quinta-feira, 27 de setembro de 2012

Anti scans e DDOS no conntrack !

Esses asiáticos desocupados ficam fazendo scan e criando virus horríveis que fazem mais scan... e essa merdas viram DDOS.

Recentemente tenho percebido que muitos pacotes chegam no servidor em portas e ips inutilizados. O número de conexões possíveis é limitado em 65535 ! e quando o invasor já está dentro com conexões penduradas o iptables não bloqueia até todas serem eliminadas do conntrack... então é bom ficar de olho no conntrack.

O método abaixo previne DDOS, Scans, Virus e muito mais...

É bem simples, basta colocar o conntrack2.sh no crontab (15 em 15 minutos ) ou menos dependendo da exposição... ele vai enviar o e-mail alertando, e também pode derrubar as conexões killconnections.sh e bloquear o invasor.

Se for utilizar atenção com os detalhes de rede local, no meu caso "10\.1" e se você tiver serviços que recebam mais de 3000 conexões coloque um grep -v também !

conntrack2.sh
-------------------------------------------------------------------------------
#!/bin/bash
N2=3000
cd /root/
cat /proc/net/ip_conntrack | cut -f2 -d"=" | awk {'print $1'} | sort | uniq -c| sort | tail -n 10 | grep -v " 10\.1" > /root/conntrack2.log
cat /root/conntrack2.log
for i in `cat /root/conntrack2.log | awk {'print $2'}`
do
N1=`cat /root/conntrack2.log | grep $i | awk {'print $1'}`
if [ $N1 -gt $N2 ];then
(:
echo 'HELO mail';sleep 1
echo 'mail From:<suporte>';
echo 'rcpt To:<suporte>';
echo 'data';
echo 'subject: ' "Tentativa de Invasao";
echo 'Sender: <suporte>';
echo 'To: <suporte>';
echo '';
echo "mais de $N2 conexoes do $i Total $N1 conexoes provavel tentativa de invasao";
echo `whois $i | grep "owner:"`;
echo ".";
echo 'quit' ;) | nc mail 25
#matar as conexões

killconnections.sh $i

echo $i >> /root/blacklist.lst

iptables -A INPUT -s $i -j DROP

fi
done

-------------------------------------------------------

killconnections.sh
if [ -z $1 ] ; then
exit
fi
grep -E "^tcp .{10,25}ESTABLISHED src=$1 " /proc/net/ip_conntrack | while read line ; do
S_IP=`echo $line | awk '{print substr($5,5)}'`
S_SOCK=`echo $line | awk '{print substr($7,7)}'`
D_IP=`echo $line | awk '{print substr($6,5)}'`
D_SOCK=`echo $line | awk '{print substr($8,7)}'`
echo "$S_IP:$S_SOCK $D_IP:$D_SOCK"
hping2 $D_IP -R -s $S_SOCK -p $D_SOCK -a $S_IP -k -c 1 >/dev/null 2>/dev/null &
done

segunda-feira, 16 de janeiro de 2012

Lição 2 - Programação de Jogos em ShellScript

A lição 2 fala sobre movimento, é um assunto muito legal, basicamente o que todos querem saber antes de iniciar a programação de um game.

Alem do movimento tem muita filosofia aqui. então vou tentar explicar todos os detalhes.

Nesse script você pode usar as letras (a,s,w,s) para movimentar a bolinha, e o (q) para sair.

#!/bin/bash

setterm -cursor off

clear

x=0

y=0

a=0

f=0

echo -n "o"

until [ $a = q ];do

read -n 1 a

clear

######## Leitura do Teclado ####

if [ $a = a ];then

let "x = x - 1"

if [ $a = d ];then

let "x = x + 1"

if [ $a = w ];then

let "y = y - 1"

if [ $a = s ];then

let "y = y + 1"

################################

##### Movimento da Bolinha #####

f=0

while [ $y -gt $f ];do

echo ""

let "f = f + 1"

done

f=0

while [ $x -gt $f ];do

echo -n " "

let "f = f + 1"

done

echo -n "o"

done

###############################

clear

setterm -cursor on

echo FIM

OK, agora que você brincou vamos falar sobre o script

setterm -cursor off

Aqui eu desligo o quadrado do cursor de digitação, para que apenas o que eu quero seja exibido.

clear

x=0

y=0

a=0

Apos isso limpo a tela e inicio todas as minhas variáveis com o valor que quero. é importante fazer isso para não haver erros na inicialização.

until [ $a = q ];do

read -n 1 a

clear

Incio o loop, e tem mais uma coisa importante aqui, o read -n1 a, pega apenas a tecla batida, ele não precisa do enter.

Apos isso sigo com o conceito de gráfico x,y que definem onde vou exibir o "o"

E de bônus, eu deveria usar um comando para fazer o sistema imprimir o "o" onde eu quero. mas me imaginei em um sistema ou linguagem onde não teria nem mesmo isso. e montei na marra.

imprimindo o numero de linhas [echo], e imprimindo colunas [echo -n " "] para chegar na posição x,y.

Lição 1 - Programação de Jogos em ShellScript

Estarei postando aqui um tutorial sobre programação de jogos na linguagem ShellScript, claro que ninguém vai lançar jogos em ShellScript mas as lições aqui podem ser empregadas em qualquer outra linguagem, ou programa visto que são usados comandos básicos.

Aos programadores profissionais entendam que nunca fiz curso de programação, então meus métodos são esquisitos mesmo.

Lição 1 - Animações

Uma bela animação na intro pode definir o sucesso de um game, então vejam o exemplo de como fazer animações em ShellScript, isso é ótimo inclusive pra tirar sarro dos colegas.

#!/bin/bash

clear

echo " o"

echo "/|\\"

echo "/ \\"

sleep 1

clear

echo " o"

echo " /|\\"

echo " / \\"

sleep 1

clear

echo " o"

echo " /|\\"

echo " / \\"

Que legal, o bonequinho andou :)

ok ok, inútil mas para salvar o tópico algumas informações do sleep.

1. você pode utilizar sleep 0.5 para esperar meio segundo

2. alem disso existe o comando usleep que trabalha com milissegundos.