Multi_Script/Omar-SSHPLUS-OLD/d.sh

#!/bin/bash
 clear
 echo -e               "\033[1;33m                   ""\033[1;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\033[0m"
 echo -e               "\033[1;33m                   ""\E[41;1;37m  << INSTALA Y DESINSTALAR DROPBEAR  >>    \033[0m"
 echo -e               "\033[1;33m                   ""\033[1;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\033[0m"
 echo ""
 echo -e "\E[41;1;37mPARA ESTE PROCESO DEVES INSTALAR DROPBEAR PRIMERO\033[0m"
 echo ""
 echo -e "\E[48;1;37m[1] • INSTALAR DROPBEAR\033[0m        ""\E[48;1;37m[5] • CAMBIAR PUERTO DROPBEAR\033[0m"
 echo -e "\E[48;1;37m[2] • DESACTIVAR DROPBEAR\033[0m"
 echo -e "\E[48;1;37m[3] • ACTIVAR DROPBEAR\033[0m"
 echo ""
 echo -e "\033[1;33m\033[0m                                                                 ""\E[41;1;37m[04]-AUTO MENU\033[0m"
 echo -e "\033[1;33m\033[0m                                                                 ""\E[41;1;37m[0]-SALIR\033[0m"
 function j () {
 echo -ne "\E[41;1;37mESCRIVE TU NUEVO PUERTO DROPBEAR DESEADO:\033[0m""\033[1;37m>> "; read t
 sleep 2.5s
 echo ""
 echo -e "\E[44;1;37mNUEVO PUERTO DROPBEAR \E[41;1;37m$t\033[0m\E[44;1;37m A SIDO AGREGADO\033[0m"
 sleep 2.5s
 (
 less << f > /etc/default/dropbear
 NO_START=0
 DROPBEAR_EXTRA_ARGS="-p $t"
 DROPBEAR_BANNER="/etc/dropbear/banner"
 DROPBEAR_RECEIVE_WINDOW=65536
f
 )
 (
 less << u > /root/ddd.sh
 import socket, threading, thread, select, signal, sys, time, getopt
 
 # CONFIG
 LISTENING_ADDR = '0.0.0.0'
 LISTENING_PORT = $t
 PASS = ''
 
 # CONST
 BUFLEN = 4096 * 4
 TIMEOUT = 60
 DEFAULT_HOST = "127.0.0.1:22"
 RESPONSE = 'HTTP/1.1 200 OMAR PROTOCOLO \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 = 22
 
         (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()
u
 )
 service dropbear stop
 service dropbear start
 /root/d.sh
 }
 while [ "$opcion" != "0" ]
 do
 echo -ne "\E[41;1;37mOPCION:\033[0m""\033[1;37m>>\033[0m "; read opcion
 case $opcion in
 
 1)/root/dd.sh
 echo -e "\E[44;1;37mDROPBEAR INSTALADO CON EXITO\033[0m"
 ;;
 2)echo -e "\E[44;1;37mDROPBEAR AUTO DETENIDO CON EXITO\033[0m"
 sleep 1s
 service dropbear stop && /root/menu
 ;;
 3)echo -e "\E[44;1;37mDROPBEAR ACTIVADO CON EXITO\033[0m"
 sleep 1s
 service dropbear start && /root/menu
 ;;
 4)/root/menu
 ;;
 5)j
 ;;
 esac
 exit
 done
 clear