Multi_Script/Omar-SSHPLUS-OLD/auto.sh

#!/bin/bash
 rm -rf /etc/stunnel/stunnel.pem
 barra="\033[0;34m—————————————————————————————————————————————————————— \033[0m"
 cor[0]="\033[0m" #SEN CORE
 cor[1]="\033[0;34m" #AZUL
 cor[2]="\033[1;32m" #VERDE
 cor[3]="\033[1;37m" #BRAN
 cor[4]="\033[1;36m" #MAG
 cor[5]="\033[1;33m" #AMAREL
 cor[6]="\033[1;35m" #MAGENTA
 cor[7]="\033[1;31m" #VERMELHO
 fun_bar () {
 comando[0]="$1"
 comando[1]="$2"
  (
 [[ -e $HOME/fim ]] && rm $HOME/fim
 ${comando[0]} > /dev/null 2>&1
 ${comando[1]} > /dev/null 2>&1
 touch $HOME/fim
  ) > /dev/null 2>&1 &
  tput civis
 echo -ne "  \033[1;33mAGUARDE \033[1;37m- \033[1;33m["
 while true; do
    for((i=0; i<18; i++)); do
    echo -ne "\033[1;31m#"
    sleep 0.1s
    done
    [[ -e $HOME/fim ]] && rm $HOME/fim && break
    echo -e "\033[1;33m]"
    sleep 1s
    tput cuu1
    tput dl1
    echo -ne "  \033[1;33mAGUARDE \033[1;37m- \033[1;33m["
 done
 echo -e "\033[1;33m]\033[1;37m -\033[1;32m INSTALADO !\033[1;37m"
 tput cnorm
 }
 inst_ssl () {
 pkill -f stunnel4
 pkill -f stunnel
 pkill -f 443
 pkill -f v2ray
 pkill -f v2-ui
 apt-get purge stunnel4 -y
 apt-get purge stunnel -y
 apt-get install stunnel4 -y
 apt-get install stunnel -y
 pt=$(netstat -nplt |grep 'sshd' | awk -F ":" NR==1{'print $2'} | cut -d " " -f 1)
 echo -e "cert = /etc/stunnel/stunnel.pem\nclient = no\nsocket = a:SO_REUSEADDR=1\nsocket = l:TCP_NODELAY=1\nsocket = r:TCP_NODELAY=1\n\n[stunnel]\nconnect = 127.0.0.1:${pt}\naccept = 443" > /etc/stunnel/stunnel.conf
 openssl genrsa -out key.pem 2048 > /dev/null 2>&1
 (echo $crt; echo $crt; echo $crt; echo $crt; echo $crt; echo $crt; echo $crt)|openssl req -new -x509 -key key.pem -out cert.pem -days 1050 > /dev/null 2>&1
 cat key.pem cert.pem >> /etc/stunnel/stunnel.pem
 sed -i 's/ENABLED=0/ENABLED=1/g' /etc/default/stunnel4
 service stunnel4 restart
 service stunnel restart
 service stunnel4 start
 }
 
 inst_py () {
 
 pkill -f 80
 pkill python
 apt install python -y
 apt install screen -y
 
 pt=$(netstat -nplt |grep 'sshd' | awk -F ":" NR==1{'print $2'} | cut -d " " -f 1)
 
  cat <<EOF > proxy.py
 import socket, threading, thread, select, signal, sys, time, getopt
 
 # CONFIG
 LISTENING_ADDR = '0.0.0.0'
 LISTENING_PORT = 1080
 PASS = ''
 
 # CONST
 BUFLEN = 4096 * 4
 TIMEOUT = 60
 DEFAULT_HOST = "127.0.0.1:$pt"
 RESPONSE = 'HTTP/1.1 101 Switching Protocols \r\n\r\n'
  
 class Server(threading.Thread):
     def __init__(self, host, port):
         threading.Thread.__init__(self)
         self.running = False
         self.host = host
         self.port = port
         self.threads = []
 	self.threadsLock = threading.Lock()
 	self.logLock = threading.Lock()
 
     def run(self):
         self.soc = socket.socket(socket.AF_INET)
         self.soc.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
         self.soc.settimeout(2)
         self.soc.bind((self.host, self.port))
         self.soc.listen(0)
         self.running = True
 
         try:                    
             while self.running:
                 try:
                     c, addr = self.soc.accept()
                     c.setblocking(1)
                 except socket.timeout:
                     continue
                 
                 conn = ConnectionHandler(c, self, addr)
                 conn.start();
                 self.addConn(conn)
         finally:
             self.running = False
             self.soc.close()
             
     def printLog(self, log):
         self.logLock.acquire()
         print log
         self.logLock.release()
 	
     def addConn(self, conn):
         try:
             self.threadsLock.acquire()
             if self.running:
                 self.threads.append(conn)
         finally:
             self.threadsLock.release()
                     
     def removeConn(self, conn):
         try:
             self.threadsLock.acquire()
             self.threads.remove(conn)
         finally:
             self.threadsLock.release()
                 
     def close(self):
         try:
             self.running = False
             self.threadsLock.acquire()
             
             threads = list(self.threads)
             for c in threads:
                 c.close()
         finally:
             self.threadsLock.release()
 			
 
 class ConnectionHandler(threading.Thread):
     def __init__(self, socClient, server, addr):
         threading.Thread.__init__(self)
         self.clientClosed = False
         self.targetClosed = True
         self.client = socClient
         self.client_buffer = ''
         self.server = server
         self.log = 'Connection: ' + str(addr)
 
     def close(self):
         try:
             if not self.clientClosed:
                 self.client.shutdown(socket.SHUT_RDWR)
                 self.client.close()
         except:
             pass
         finally:
             self.clientClosed = True
             
         try:
             if not self.targetClosed:
                 self.target.shutdown(socket.SHUT_RDWR)
                 self.target.close()
         except:
             pass
         finally:
             self.targetClosed = True
 
     def run(self):
         try:
             self.client_buffer = self.client.recv(BUFLEN)
         
             hostPort = self.findHeader(self.client_buffer, 'X-Real-Host')
             
             if hostPort == '':
                 hostPort = DEFAULT_HOST
 
             split = self.findHeader(self.client_buffer, 'X-Split')
 
             if split != '':
                 self.client.recv(BUFLEN)
             
             if hostPort != '':
                 passwd = self.findHeader(self.client_buffer, 'X-Pass')
 				
                 if len(PASS) != 0 and passwd == PASS:
                     self.method_CONNECT(hostPort)
                 elif len(PASS) != 0 and passwd != PASS:
                     self.client.send('HTTP/1.1 400 WrongPass!\r\n\r\n')
                 elif hostPort.startswith('127.0.0.1') or hostPort.startswith('localhost'):
                     self.method_CONNECT(hostPort)
                 else:
                     self.client.send('HTTP/1.1 403 Forbidden!\r\n\r\n')
             else:
                 print '- No X-Real-Host!'
                 self.client.send('HTTP/1.1 400 NoXRealHost!\r\n\r\n')
 
         except Exception as e:
             self.log += ' - error: ' + e.strerror
             self.server.printLog(self.log)
 	    pass
         finally:
             self.close()
             self.server.removeConn(self)
 
     def findHeader(self, head, header):
         aux = head.find(header + ': ')
     
         if aux == -1:
             return ''
 
         aux = head.find(':', aux)
         head = head[aux+2:]
         aux = head.find('\r\n')
 
         if aux == -1:
             return ''
 
         return head[:aux];
 
     def connect_target(self, host):
         i = host.find(':')
         if i != -1:
             port = int(host[i+1:])
             host = host[:i]
         else:
             if self.method=='CONNECT':
                 port = 443
             else:
                 port = 80
 
         (soc_family, soc_type, proto, _, address) = socket.getaddrinfo(host, port)[0]
 
         self.target = socket.socket(soc_family, soc_type, proto)
         self.targetClosed = False
         self.target.connect(address)
 
     def method_CONNECT(self, path):
         self.log += ' - CONNECT ' + path
         
         self.connect_target(path)
         self.client.sendall(RESPONSE)
         self.client_buffer = ''
 
         self.server.printLog(self.log)
         self.doCONNECT()
 
     def doCONNECT(self):
         socs = [self.client, self.target]
         count = 0
         error = False
         while True:
             count += 1
             (recv, _, err) = select.select(socs, [], socs, 3)
             if err:
                 error = True
             if recv:
                 for in_ in recv:
 		    try:
                         data = in_.recv(BUFLEN)
                         if data:
 			    if in_ is self.target:
 				self.client.send(data)
                             else:
                                 while data:
                                     byte = self.target.send(data)
                                     data = data[byte:]
 
                             count = 0
 			else:
 			    break
 		    except:
                         error = True
                         break
             if count == TIMEOUT:
                 error = True
 
             if error:
                 break
 
 
 def print_usage():
     print 'Usage: proxy.py -p <port>'
     print '       proxy.py -b <bindAddr> -p <port>'
     print '       proxy.py -b 0.0.0.0 -p 1080'
 
 def parse_args(argv):
     global LISTENING_ADDR
     global LISTENING_PORT
     
     try:
         opts, args = getopt.getopt(argv,"hb:p:",["bind=","port="])
     except getopt.GetoptError:
         print_usage()
         sys.exit(2)
     for opt, arg in opts:
         if opt == '-h':
             print_usage()
             sys.exit()
         elif opt in ("-b", "--bind"):
             LISTENING_ADDR = arg
         elif opt in ("-p", "--port"):
             LISTENING_PORT = int(arg)
     
 
 def main(host=LISTENING_ADDR, port=LISTENING_PORT):
     
     print "\n ==============================\n"
     print "\n         PYTHON PROXY          \n"
     print "\n ==============================\n"
     print "corriendo ip: " + LISTENING_ADDR
     print "corriendo port: " + str(LISTENING_PORT) + "\n"
     print "Se ha Iniciado Por Favor Cierre el Terminal\n"
     
     server = Server(LISTENING_ADDR, LISTENING_PORT)
     server.start()
 
     while True:
         try:
             time.sleep(2)
         except KeyboardInterrupt:
             print 'Stopping...'
             server.close()
             break
     
 if __name__ == '__main__':
     parse_args(sys.argv[1:])
     main()
EOF
 
 screen -dmS pythonwe python proxy.py -p 80&
 
 }
 
 clear
 clear
 echo -e "$barra"
 echo -e "\033[1;36mPAYLOAD + SSL \033[1;33m[BY KILLSHITO] "
 echo -e "$barra"
 echo -e "\033[1;32mSCRIPT AUTOCONFIGURACION "
 echo -e "$barra"
 echo -e "\033[1;37mRequiere tener el puerto libre ,80 y el 443"
 echo -e "$barra"
 echo -ne " \033[1;37mDeseja Prosseguir? [S/N]: "; read x
 [[ $x = @(n|N) ]] && echo -e "$barra" && exit 0
 echo -e "$barra"
 echo -e "\033[1;36m Instalando SSL.. "
 echo -e "$barra"
 fun_bar 'inst_ssl'
 echo -e "$barra"
 echo -e "\033[1;36m Configurando PYTHON.. "
 echo -e "$barra"
 fun_bar 'inst_py'
 rm -rf proxy.py
 echo -e "$barra"
 echo -e " \033[1;37mAHORA HAGA LO SIGUENTE "
 echo -e " \033[1;37mPARA CREAR UN USUARIO ESCRIBA :CREARUSER "
 echo -e " \033[1;37mPARA REMOVE UN USUARIO ESCRIBA :REMOUSER "
 echo -e "$barra"
 echo
 echo
 echo '
 echo
 read -p "Usuario :" name
 read -p "Contraseña :" pass
 useradd -M -s /bin/false $name
 (echo $pass; echo $pass)|passwd $name 2>/dev/null' > /bin/CREARUSER &&chmod +x /bin/CREARUSER
 echo '
 echo
 read -p "Escriba su usuario que desa remover :" user
 kill $(ps -u $user |awk '{print $1}') >/dev/null 2>/dev/null ; userdel --force $us' >/bin/REMOUSER &&chmod +x /bin/REMOUSER
 echo -e "\E[44;1;37mPRESIONA 0 PARA SALIR DE TODO\033[0m" "\E[41;1;37m[15]-AUTO MENU\033[0m" 
 while [ "$opcion" != "0" ]
 do
 echo -ne "\E[41;1;37mOPCION:\033[0m""\033[1;37m>>\033[0m "; read opcion
 case $opcion in
 
 15)/root/menu
 ;;
 esac
 exit
 done