home *** CD-ROM | disk | FTP | other *** search
/ The Hacker's Encyclopedia 1998 / hackers_encyclopedia.iso / zines / phrack2 / phrack52.016 < prev    next >
Encoding:
Text File  |  2003-06-11  |  30.4 KB  |  984 lines
  1. ---[  Phrack Magazine   Volume 8, Issue 52 January 26, 1998, article 16 of 20
  2.  
  3.  
  4. -------------------------[  Piercing Firewalls
  5.  
  6.  
  7. --------[  bishnu@hotmail.com
  8.  
  9.  
  10. Introduction:
  11.  
  12.     Many ISPs manage a firewall to protect their users against the hostile
  13. Internet.  While the firewall might protect the users, it also serves to limit
  14. their freedom.
  15.  
  16.     Most firewalls don't allow a connection to be established if the
  17. initiative is coming from the outside, as this automatically disables many
  18. security vulnerabilities.  Unfortunately, this also means that many other
  19. things are not possible; for example, sending an X-display to a machine behind 
  20. the firewall, or something similar.
  21.  
  22.     One solution is to ask the firewall administrator to configure the firewall
  23. not to disable X connections (or the port you plan to use.  This normally
  24. means allowing connections on port 6000 to penetrate the firewall.  But often
  25. the admin does not want to, as he is either too busy, hasn't figured out how
  26. to configure the firewall yet, or simply refuses to, as it violates the site
  27. security policy.  Maybe you don't even want him to know that you plan to send
  28. some traffic backwards.
  29.  
  30.     For this purpose I wrote two simple programs that transmit TCP connections
  31. back thorough a tunnel, to your machine.
  32.  
  33.  
  34. The tunnel:
  35.  
  36.     The solution is two programs, one running at your machine, or some other
  37. machine behind the firewall, and another running at some *NIX-box on the
  38. Internet.  The program behind the firewall (called tunnel) connects to a
  39. program (called portal) on the machine on the Internet.  This connection
  40. probably won't be intercepted by the firewall (depending on the security
  41. policy), as it is outgoing.  Once the connection from the tunnel to the portal
  42. is established, the portal opens a port for incoming TCP traffic, and we are
  43. ready to rock.  Whenever a machine connects to the portal it sends the request
  44. back to the tunnel thorough the already established connection through the
  45. firewall, the tunnel will then forward the connection to your machine.
  46.  
  47.     The effect will be that you drag a port on your machine (or any machine
  48. behind the firewall) onto the other side of the firewall, which means that
  49. anyone can connect to it regardless of the site's security policy.
  50.  
  51. An example: 
  52.  
  53. Goof: Your machine.
  54. Foo : Some other machine behind the firewall or same as Goof, running 'tunnel'.
  55. Bar : Some machine on the other side of the firewall running 'portal'.
  56. Boof: Some machine wanting to connect to machine Goof, or same as Bar.
  57.  
  58.                   FIREWALL
  59.   tunnel             ^          portal
  60. #########            ^         #########
  61. #  Foo  #======================#  Bar  #
  62. #########            ^         #########
  63.     |                ^             |
  64.     |                ^             |
  65.     |                ^             |
  66. #########            ^         #########
  67. # Goof  #            ^         # Boof  #
  68. #########            ^         #########
  69.                   FIREWALL
  70.  
  71.  
  72.  
  73.    You are sitting on machine Goof, and you run some program on machine Boof,
  74. this program happens to be using X-windows, so you want to send the display
  75. back to machine Goof. X-windows tries to establish a TCP connection through
  76. the firewall, which is 'burned'.
  77.  
  78.    So you start the tunnel on machine Foo, and set it to connect to machine
  79. Bar at lets say port 7000 (where the portal is running), also you set the
  80. tunnel to forward all TCP connections, coming back from the portal, to your
  81. machine Goof on port 6000 (X-windows).  You start the portal on machine Bar,
  82. and you make it listen for the tunnel on port 7000.  Once the tunnel has
  83. connected, the portal listens on port 6001 for incoming X.  Whenever some
  84. X-application connects to the portal, the connection is passed to the tunnel,
  85. which then forwards it to machine Goof on port 6000.
  86.  
  87.    Finally on machine Boof you set your display to machine Bar:1 (in a tcsh
  88. type 'setenv DISPLAY bar:1', in bash 'export DISPLAY=bar:1'), which tells the
  89. application to use port 6001 (We can't use port 6000 if the machine is running
  90. a X-server itself). You start your Xeyes, and they pop in your face.
  91.  
  92.  
  93. Conclusion:
  94.  
  95.    If you use this program to cross a firewall you surely violate the ISP's
  96. security policy, as anybody can cross it as well, that is if they know, and 
  97. there is nothing like security by obscurity.  So don't tell your mom.
  98.  
  99.    An advantage of this approach is that you don't need to have root access on 
  100. either machine, which is makes the whole process a bit easier. 
  101.  
  102. To compile the code, just do a `make`.  It has been tested on
  103.     Solaris 2.5.x, 2.6
  104.     IRIX 6.[2,3,4]
  105.     FreeBSD 2.1.5
  106.     HPUX 10.x
  107.     Linux 2.0.x
  108.  
  109.  
  110. ----[  THE CODE
  111.  
  112.  
  113. <++> tunnel/Makefile
  114. CC = gcc
  115.  
  116. OSFLAGS = 
  117. MYFLAGS = -Wall -O2 -g -pedantic
  118. CFLAGS = $(MYFLAGS) $(PROFILE) $(OSFLAGS)
  119.  
  120. #If you compile on Solaris 2.x, uncomment the following line
  121. #LOCAL_LIBRARIES = -lsocket
  122.  
  123. TUNNEL_OBJFILES = tunnel.o share.o
  124. PORTAL_OBJFILES = portal.o share.o
  125.  
  126. all: tunnel portal
  127.  
  128. tunnel :   $(TUNNEL_OBJFILES) share.h
  129.        $(CC) $(TUNNEL_OBJFILES) $(LOCAL_LIBRARIES) -o tunnel
  130. tunnel.o : tunnel.c share.h
  131.     $(CC) -c $(CFLAGS) $(COMMFLAGS) tunnel.c
  132. portal :   $(PORTAL_OBJFILES) share.h
  133.        $(CC) $(PORTAL_OBJFILES) $(LOCAL_LIBRARIES) -o portal
  134. portal.o : portal.c share.h
  135.     $(CC) -c $(CFLAGS) $(COMMFLAGS) portal.c
  136. share.o : share.c share.h
  137.     $(CC) -c $(CFLAGS) $(COMMFLAGS) share.c
  138. clean:
  139.     rm -f *.o tunnel portal core
  140. <-->
  141. <++> tunnel/tunnel.c
  142. /*
  143. -TUNNEL-
  144.  
  145. This is the tunnel part of my firewall piercer. This code is supposed
  146. to be running on the inside of the firewall. The tunnel should then
  147. connect to the portal running on the outside.  
  148.  
  149. start it like:
  150. >% tunnel localhost 23 protal.machine.com 3001
  151.  
  152. if the portal is running at port 3001 at portal.machine.com, incoming
  153. connections to the portal will get rerouted to this machines telnet
  154. port.
  155.  
  156.  */
  157.  
  158. #include <stdio.h>
  159. #include <stdlib.h>
  160. #include <unistd.h> 
  161. #include <netinet/in.h> 
  162. #include <sys/socket.h> 
  163. #include <sys/time.h> 
  164. #include <string.h> 
  165. #include <signal.h>
  166. #include <errno.h>
  167. #include "share.h"
  168.  
  169.  
  170. extern char tunnel_buf[MAXLEN*2];
  171. char buf[MAXLEN*2];
  172. extern int tunnel_des;   /* The socket destination of a tunnel packet*/
  173. extern int tunnel_src;   /* The socket source of a tunel packet*/
  174. extern int tunnel_size;  /* Size of tunnel packet*/
  175. extern struct connections connections; /*Linked list of connections*/
  176.  
  177. char *remote_machine;                /*remote machine name to tunnel to*/
  178. extern int  tunnel_port;             /*tunnel port*/
  179. extern int  tunnel_sock;             /*tunnel socket*/
  180. char *login_machine="";              /*machine to forward connections to*/
  181. int login_port;                      /*port to forward connections to*/
  182.  
  183. int oldtime=0,ping_time=0;
  184. struct connection *descriptors[DESC_MAX];
  185. extern struct connection *descriptors[DESC_MAX];
  186. extern int errno;
  187. FILE *log=stdout;             /*logfile = stdout by default*/
  188.  
  189. void open_tunnel(){
  190.   tunnel_sock=remote_connect(remote_machine,tunnel_port);
  191. }
  192.  
  193.  
  194. extern int optind;
  195. extern char *optarg;
  196.  
  197. void usage(){
  198.   printf("Usage: tunnel [-l logfile] <forward_machine> <forward_port>" \
  199.      " <portal_machine> <portal_port>\n");
  200.   printf("where:\n");
  201.   printf("forward_machine is the machine to which the traffic is forwarded\n");
  202.   printf("forward_port is the port to which the traffic is forwarded\n");
  203.   printf("portal_machine is the machine we want to route the trafic from\n");
  204.   printf("portal_port is the port we want to route the trafic from\n");
  205.   printf("Coded by %s\n",AUTHOR);
  206. }
  207.  
  208.  
  209. /********************** Get the options ***********************/
  210.  
  211. void get_options(int argc,char *argv[]){
  212.   int c;
  213.   while((c=getopt(argc,argv, "l:")) !=-1)
  214.     switch(c){
  215.     case 'l':
  216.       if(!(log=fopen(optarg,"w"))){
  217.     log=stdout;
  218.     fprintf(log,"Unable to open logfile '%s':%s\n",
  219.         optarg,strerror(errno));
  220.       }
  221.       break;
  222.     case '?':
  223.     default:
  224.       usage();
  225.       exit(-1);
  226.     }
  227.   /* the two next options*/
  228.   if(argc-optind!=4){
  229.     printf("Wrong number of options!\n");
  230.     usage();
  231.     exit(-1);
  232.   }
  233.   login_machine=get_ip(argv[optind++]);
  234.   login_port=atoi(argv[optind++]);
  235.   remote_machine=get_ip(argv[optind++]);
  236.   tunnel_port=atoi(argv[optind++]);
  237.   if(login_port<1||login_port>65535||tunnel_port<1||tunnel_port>65535){ 
  238.     printf("Ports below 1 and above 65535 don't give any sense\n"); 
  239.     usage(); 
  240.     exit(-1);
  241.   } 
  242. }
  243.  
  244. void alive(){
  245.   /* To check wether the line is still alive, we Myping it every
  246.      ALIVE_TIME seconds. If we don't get a ping from the tunnel
  247.      every ALIVE_TIME*2 we disconnect the connection to the
  248.      portal, and wait for a new.  If the portal has not died, all
  249.      the connections through the tunnel will continue as normal once
  250.      the connection has been established again.
  251.      The reason why I do this is because some firewalls tend to
  252.      disable connections if there hasn't been any traffic for some time, 
  253.      or if the connection had been up too long time.
  254.      */
  255.   
  256.   /*Transmit a Myping packet, we receive the 
  257.     answer in check_tunnel_connection()*/
  258.   if(time(NULL)-oldtime>=ALIVE_TIME){
  259.     oldtime=time(NULL);
  260.     transmit_tunnel(buf,0,0,0); 
  261.   }
  262.   if(time(NULL)-ping_time>ALIVE_TIME*2){
  263.     printf("Connection to portal probably lost, hanging up.\n");
  264.     shutdown(tunnel_sock,2);
  265.     close(tunnel_sock);
  266.     tunnel_sock=-1;
  267.   }
  268. }
  269.  
  270. int reset_selector(fd_set *selector,fd_set *errsel,struct connection *con)
  271. {
  272.   /* We tell the selector to look on the tunnel socket aswell 
  273.      as our live connections.*/
  274.   int maxsock,i;
  275.   FD_ZERO(selector);
  276.   FD_SET(tunnel_sock,selector);
  277.   FD_SET(tunnel_sock,errsel);
  278.   con=connections.head;
  279.   maxsock=tunnel_sock;
  280.   for(i=0;i<connections.num;i++,con=con->next){
  281.     FD_SET(con->local_sock,selector);
  282.     FD_SET(con->local_sock,errsel);
  283.     maxsock=max(maxsock,con->local_sock);
  284.   }
  285.   return(maxsock); /*We return the maximum socket number*/
  286. }
  287.  
  288. void check_tunnel_connection(fd_set *selector,fd_set *errsel,struct connection *con){
  289.   /*Here we check the tunnel for incoming data*/
  290.   if(FD_ISSET(tunnel_sock,errsel)){
  291.     fprintf(log,"Tunnel connection terminated!\n");
  292.     shutdown(tunnel_sock,2);
  293.     close(tunnel_sock);
  294.     tunnel_sock=-1;
  295.     return;
  296.   }
  297.   if(FD_ISSET(tunnel_sock,selector)){
  298.     if(receive_tunnel()!=-1){
  299.       if(tunnel_src==0&&tunnel_des==0){ /*We have a Myping packet*/
  300.     ping_time=time(NULL); /*reset the alive_timer*/
  301.       }
  302.       else if(tunnel_src==0){/*We have a 'hangup' signal for a connection*/
  303.     if((con=descriptors[tunnel_des])){
  304.       fprintf(log,"Removing connection to %s %d\n",con->host,con->port);
  305.       removeconnection(con);
  306.     }
  307.       }
  308.       else if(tunnel_des==0){ /*We have a new connection*/
  309.       int newsock;
  310.       if((newsock=remote_connect(login_machine,login_port))!=-1){
  311.         connections.num++;
  312.         con=(struct connection *)malloc(sizeof(struct connection));
  313.         con->host=(char *)malloc(MAX_HOSTNAME_SIZE);
  314.         strncpy(con->host,&tunnel_buf[4],MAX_HOSTNAME_SIZE);
  315.         con->port=ntohl((((int *)tunnel_buf)[0]));
  316.         con->local_sock=newsock;
  317.         con->remote_sock=tunnel_src;
  318.         con->time=time(NULL);
  319.         con->next=connections.head;
  320.         connections.head=con;
  321.         descriptors[newsock]=con;
  322.         fprintf(log,"Connected the incoming call from %s %d to %s %d\n",con->host,con->port,login_machine,login_port);
  323.         /*Acknowledge the new connection to the portal*/
  324.         transmit_tunnel(buf,0,con->local_sock,con->remote_sock);
  325.       } 
  326.     }
  327.       else if(descriptors[tunnel_des]){
  328.     /*Send the data to the right descriptor*/
  329.     writen(descriptors[tunnel_des]->local_sock,tunnel_buf,tunnel_size);
  330.       }
  331.       else{
  332.     fprintf(log,"Connection to unallocated channel, hangup signal sent\n");
  333.     /*Send a hangup signal to the portal, to disable the connection*/
  334.     transmit_tunnel(buf,0,0,tunnel_src);
  335.       }
  336.     }
  337.   }
  338. }
  339.  
  340. void main(int argc,char **argv)
  341. {
  342.   get_options(argc,argv);
  343.   fprintf(log,"Opening tunnel to %s port %d\n",remote_machine,tunnel_port);
  344.   fprintf(log,"Tunnelconnections will be forwarded to host %s"\
  345.       " port %d\n",login_machine,login_port);
  346.   connections.num=0;
  347.   connections.head=NULL;
  348.   signal(SIGINT,ctrlC);
  349.   while(1){                       /*The tunnel runs infinitely*/
  350.     struct connection *con=connections.head;
  351.     open_tunnel();
  352.     ping_time=time(NULL);
  353.     while(tunnel_sock!=-1){
  354.       fd_set selector,errsel;
  355.       struct timeval alive_time;
  356.       alive_time.tv_sec=ALIVE_TIME;
  357.       alive_time.tv_usec=0;
  358.       alive();   /*Check wether the tunnelconnection is alive*/
  359.       /* We have to listen to the tunnel and all the current connections.
  360.        we do that with a select call*/
  361.       if(select(reset_selector(&selector,&errsel,con)+1,
  362.         &selector,NULL,&errsel,&alive_time)){
  363.     /*Check for each of the local connections*/
  364.     check_local_connections(&selector,&errsel,con);
  365.     /*Check for the tunnel*/
  366.     check_tunnel_connection(&selector,&errsel,con);
  367.       }
  368.     }
  369.     sleep(RETRY_TIME); /*We sleep a while*/ 
  370.     /* fprintf(log,"Trying to connect to portal.\n"); */
  371.   }
  372. }
  373. <-->
  374. <++> tunnel/portal.c
  375. /*
  376. -PORTAL-
  377.  
  378. This is the portal part of my firewall piercer. This code is supposed
  379. to be running on the outside of the firewall. The tunnel part should
  380. then connect trough the firewall to this program.
  381. start it like:
  382. >% portal 3000 3001
  383. for tunnel connection on port 3001 and incoming calls on 3000.
  384.  
  385. when you connect to the portal at port 3000 your connection will be
  386. forwarded to the tunnel.
  387.  
  388. */
  389.  
  390. #include <stdio.h>
  391. #include <stdlib.h>
  392. #include <unistd.h>
  393. #include <netinet/in.h> 
  394. #include <sys/socket.h> 
  395. #include <sys/time.h>
  396. #include <string.h>
  397. #include <netdb.h> 
  398. #include <unistd.h>
  399. #include <signal.h>
  400. #include <errno.h>
  401. #include "share.h"
  402.  
  403. /***************/
  404. /* Global data */
  405. /***************/
  406. extern char tunnel_buf[MAXLEN*2];
  407. extern int tunnel_des;
  408. extern int tunnel_src;
  409. extern int tunnel_size;
  410. extern struct connections connections;
  411. extern struct connection *descriptors[DESC_MAX];
  412. extern int errno;
  413. extern int  tunnel_port;             /*tunnel port*/
  414. extern int  tunnel_sock;             /*tunnel new accepted socket*/
  415.  
  416. char buf[MAXLEN*2];
  417. char *remote_machine;         /*remote machine name*/
  418. int  tunnel_basesock;         /*tunnel base socket*/
  419. int local_sock;               /* local port socket*/
  420. int local_port;               /*local machine port*/
  421. FILE *log=stdout;             /*logfile = stdout by default*/
  422. int ping_time=0;
  423.  
  424.  
  425. /********************** Usage  ***********************/
  426. void usage(){
  427.  
  428.   fprintf(stderr,"Usage: portal [-l logfile] <local_port> <tunnel_port>\n");
  429.   fprintf(stderr,"where:\n");
  430.   fprintf(stderr,"local_port is the port where we accept incoming" \
  431.       " connections\n");
  432.   fprintf(stderr,"remote_port is the port where we accept the tunnel" \
  433.       " to connect\n");
  434.   fprintf(stderr,"Coded by %s\n",AUTHOR);
  435. }
  436.  
  437. /********************** Get the options ***********************/
  438.  
  439. extern int optind;
  440. extern char *optarg;
  441.  
  442. void get_options(int argc,char *argv[]){
  443.   int c;
  444.   while((c=getopt(argc,argv, "l:")) !=-1)
  445.     switch(c){
  446.     case 'l':
  447.       if(!(log=fopen(optarg,"w"))){
  448.     log=stdout;
  449.     fprintf(log,"Unable to open logfile '%s':%s\n",
  450.         optarg,strerror(errno));
  451.       }
  452.       break;
  453.     case '?':
  454.     default:
  455.       usage();
  456.       exit(-1);
  457.     }
  458.   /* the two next options*/
  459.   if(argc-optind!=2){
  460.     printf("Wrong number of options!\n");
  461.     usage();
  462.     exit(-1);
  463.   }
  464.   local_port=atoi(argv[optind++]);
  465.   tunnel_port=atoi(argv[optind++]);
  466.   if(local_port<1||local_port>65535||tunnel_port<1||tunnel_port>65535){ 
  467.     printf("Ports below 1 and above 65535 dont give any sense\n"); 
  468.     usage(); 
  469.     exit(-1);
  470.   } 
  471. }
  472.  
  473. /*********************************************************/
  474. /*************** Portal                  *****************/
  475. /*********************************************************/
  476.  
  477. void open_local_port(){
  478.   /*Open the local port for incoming connections*/
  479.   struct sockaddr_in ser;
  480.   int opt=1;
  481.   local_sock=socket(AF_INET,SOCK_STREAM,0);
  482.   if(local_sock==-1){fprintf(log,"Error opening socket\n");exit(0);}
  483.   if(setsockopt(local_sock,SOL_SOCKET,SO_REUSEADDR,
  484.         (char *)&opt,sizeof(opt))<0)
  485.     {perror("setsockopt REUSEADDR");exit(1);}
  486.   ZERO((char *) &ser,sizeof(ser));
  487.   ser.sin_family      = AF_INET;
  488.   ser.sin_addr.s_addr = htonl(INADDR_ANY);
  489.   ser.sin_port        = htons(local_port);
  490.   if(bind(local_sock,(struct sockaddr *)&ser,sizeof(ser)) ==-1 ){
  491.     fprintf(log,"Error binding to local port %d : %s\n"
  492.         ,local_port,strerror(errno));
  493.     exit(-1);
  494.   }
  495.   if(listen(local_sock,5)==-1){
  496.     fprintf(log,"Error listening to local port %d : %s"
  497.         ,local_port,strerror(errno));
  498.     exit(-1);
  499.   }
  500.   fprintf(log,"Opened local port %d on socket %d\n",local_port,local_sock);
  501. }
  502.  
  503. void open_portal(){
  504.   int opt=0;
  505.   struct sockaddr_in ser;
  506.   if((tunnel_basesock=socket(AF_INET,SOCK_STREAM,0))==-1)
  507.     {perror("socket");exit(-1);}
  508.   if(setsockopt(tunnel_basesock,SOL_SOCKET,SO_REUSEADDR,
  509.         (char *)&opt,sizeof(opt))<0)
  510.     {perror("setsockopt REUSEADDR");exit(-1);}
  511.   ZERO((char *) &ser,sizeof(ser));
  512.   ser.sin_family      = AF_INET;
  513.   ser.sin_addr.s_addr = htonl(INADDR_ANY);
  514.   ser.sin_port        = htons(tunnel_port);
  515.   if(bind(tunnel_basesock,(struct sockaddr *)&ser,sizeof(ser)) ==-1 ){
  516.     fprintf(log,"Error binding to tunnel port %d : %s\n"
  517.         ,tunnel_port,strerror(errno));
  518.     exit(-1);
  519.   }
  520.   if(listen(tunnel_basesock,5)==-1){
  521.     fprintf(log,"Error listening to tunnel port %d : %s"
  522.         ,tunnel_port,strerror(errno));
  523.     exit(-1);
  524.   }
  525. }
  526.  
  527. int accept_portal(){
  528.   struct hostent *from;
  529.   struct sockaddr_in cli;
  530.   int newsock,clilen;
  531.   clilen=sizeof(cli);
  532.   if(!tunnel_basesock){return(-1);}
  533.   /*Accept incoming calls*/
  534.   newsock=accept(tunnel_basesock,(struct sockaddr *)&cli,&clilen);
  535.   /*We want to know  know our remote host better*/
  536.   from=gethostbyaddr((char *)(&cli.sin_addr),sizeof(cli.sin_addr),PF_INET);
  537.   if(!from){
  538.     close(newsock);
  539.     return(-1);
  540.   }
  541.   fprintf(log,"Tunnel connection from:%s %d\n",from->h_name,cli.sin_port);
  542.   return(newsock);
  543. }
  544.  
  545. void close_portal(){
  546.   shutdown(tunnel_sock,1);
  547.   close(tunnel_sock);
  548. }
  549.  
  550. struct connection *receive_local(){
  551.   struct sockaddr_in cli;
  552.   int newsock,clilen;
  553.   struct hostent *from;
  554.   struct connection *con;
  555.   clilen=sizeof(cli);
  556.   /*Accept incoming calls*/
  557.   newsock=accept(local_sock,(struct sockaddr *)&cli,&clilen);
  558.   if(newsock==-1)
  559.     {fprintf(log,"Server Accept Error:%s\n",strerror(errno));exit(-1);}
  560.   /*We want to know  know our remote host better*/
  561.   from=gethostbyaddr((char *)(&cli.sin_addr),sizeof(cli.sin_addr), PF_INET);
  562.   fprintf(log,"New connection from:%s %d\n",from->h_name,cli.sin_port);
  563.   /*Add our new friend to our list of connections*/
  564.   connections.num++;
  565.   con=(struct connection *)malloc(sizeof(struct connection));
  566.   con->host=strdup(from->h_name);
  567.   con->port=cli.sin_port;
  568.   con->local_sock=newsock;
  569.   con->remote_sock=0;
  570.   con->time=time(NULL);
  571.   con->next=connections.head;
  572.   connections.head=con;
  573.   descriptors[newsock]=con;
  574.   return(con);
  575. }
  576.  
  577. void alive(){
  578.   /* If we don't get a ping from the tunnel
  579.      every ALIVE_TIME*2 we disconnect the connection to the
  580.      tunnel, and wait for a new.  If the tunnel has not died, all
  581.      the connections from the tunnel will continue as normal once
  582.      the connection has been established again*/
  583.   if(time(NULL)-ping_time>ALIVE_TIME*2){
  584.     printf("Connection to tunnel probably lost, hanging up.\n");
  585.     shutdown(tunnel_sock,2);
  586.     close(tunnel_sock);
  587.     tunnel_sock=-1;
  588.   }
  589. }
  590.  
  591. int reset_selector(fd_set *selector,fd_set *errsel,struct connection *con){
  592.   /* We tell the selector to look on the tunnel socket aswell 
  593.      as our live connections, and the connection socket.*/
  594.   int maxsock,i;
  595.   FD_ZERO(selector);
  596.   FD_SET(local_sock,selector);
  597.   FD_SET(tunnel_sock,selector);
  598.   FD_SET(local_sock,errsel);
  599.   FD_SET(tunnel_sock,errsel);
  600.   con=connections.head;
  601.   maxsock=max(local_sock,tunnel_sock);
  602.   for(i=0;i<connections.num;i++,con=con->next){
  603.     FD_SET(con->local_sock,selector);
  604.     FD_SET(con->local_sock,errsel);
  605.     maxsock=max(maxsock,con->local_sock);
  606.   }
  607.   return(maxsock);
  608. }
  609.  
  610. void check_tunnel_connection(fd_set *selector,fd_set *errsel,struct connection *con){
  611.   /*Here we check the tunnel for incoming data*/
  612.   if(FD_ISSET(tunnel_sock,errsel)){
  613.     fprintf(log,"Tunnel connection terminated!\n");
  614.     shutdown(tunnel_sock,2);
  615.     close(tunnel_sock);
  616.     tunnel_sock=-1;
  617.     return;
  618.   }
  619.   if(FD_ISSET(tunnel_sock,selector)){
  620.     if(receive_tunnel()!=-1){
  621.       if(tunnel_src==0&&tunnel_des==0){ /*We got a Myping*/
  622.     ping_time=time(NULL);
  623.     /* Ping the tunnel back!*/
  624.     transmit_tunnel(buf,0,0,0); /*Send a Myping back*/
  625.       }
  626.       else if(tunnel_des){
  627.     if(descriptors[tunnel_des]){
  628.       con=descriptors[tunnel_des];
  629.       if(tunnel_src!=0){
  630.         con->remote_sock=tunnel_src;
  631.         writen(descriptors[tunnel_des]->local_sock,tunnel_buf,tunnel_size);
  632.       }
  633.       else{
  634.         printf("Hangup signal received. Removing connection to %s %d\n",con->host,con->port);
  635.         removeconnection(con);
  636.       }
  637.     }
  638.       }
  639.     }
  640.   }
  641. }
  642.  
  643. void check_connection_port(fd_set *selector,fd_set *errsel,struct connection *con){
  644.   /*Here we check the connection port for new connections*/
  645.   if(FD_ISSET(local_sock,selector)){
  646.     con=receive_local();
  647.     if(con){
  648.       printf("Transmitting the new connection\n");
  649.       *((int *)(&buf[4]))=htonl(con->port);
  650.       strncpy(&buf[8],con->host,MAX_HOSTNAME_SIZE);
  651.       *(&buf[8]+strlen(con->host))=0;
  652.       transmit_tunnel(buf,4+min(strlen(con->host)+1,MAX_HOSTNAME_SIZE),con->local_sock,0);
  653.     }
  654.   }
  655. }
  656.  
  657. void main(int argc,char **argv){
  658.   get_options(argc,argv);
  659.   init_descriptors();
  660.   connections.num=0;
  661.   connections.head=NULL;
  662.   remote_machine=get_ip(argv[2]);
  663.   fprintf(log,"Tunneling incoming calls on port %d to port %d \n"
  664.       ,local_port,tunnel_port);
  665.   connections.num=0;
  666.   connections.head=NULL;
  667.   fprintf(log,"Opening portal\n");
  668.   open_portal();
  669.   signal(SIGINT,ctrlC);
  670.   fprintf(log,"Opening localport\n");
  671.   open_local_port();
  672.   while(1){
  673.     fprintf(log,"Waiting for tunnel connection on port %d\n",tunnel_port);
  674.     while((tunnel_sock=accept_portal())==-1) sleep(4);
  675.     ping_time=time(NULL);
  676.     while(tunnel_sock!=-1){
  677.       fd_set selector,errsel;
  678.       struct connection *con=NULL;
  679.       struct timeval alive_time;
  680.  
  681.       alive_time.tv_sec=ALIVE_TIME;
  682.       alive_time.tv_usec=0;
  683.       alive();
  684.  
  685.       /* We have to listen to the tunnel, the local port, and alle the
  686.      current connections. */
  687.       if(select(reset_selector(&selector,&errsel,con)+1,
  688.         &selector,NULL,&errsel,&alive_time)){
  689.     check_tunnel_connection(&selector,&errsel,con);
  690.     check_connection_port(&selector,&errsel,con);
  691.     check_local_connections(&selector,&errsel,con);
  692.       }
  693.     }
  694.     sleep(2);
  695.   }
  696. }
  697. <-->
  698. <++> tunnel/share.c
  699. #include <stdio.h>
  700. #include <stdlib.h>
  701. #include <unistd.h> 
  702. #include <netinet/in.h> 
  703. #include <arpa/inet.h> 
  704. #include <sys/socket.h> 
  705. #include <sys/time.h> 
  706. #include <sys/utsname.h> 
  707. #include <fcntl.h> 
  708. #include <string.h>
  709. #include <signal.h>
  710. #include <errno.h>
  711. #include <netdb.h> 
  712.  
  713. #include "share.h"
  714.  
  715. char tunnel_buf[MAXLEN*2];  /*Buffer to store the tunnel data in*/
  716. int tunnel_des;             /*Destination socket */
  717. int tunnel_src;             /*Source socket*/
  718. int tunnel_size;            /*Size of the data currently in the buffer*/
  719. int tunnel_sock;            /*The socket of the portal*/
  720. int tunnel_port;            /*The port we wan't to run on*/
  721.  
  722. extern FILE *log;           /* Our log file*/ 
  723. extern int errno;          
  724. struct connection *descriptors[DESC_MAX];
  725. struct connections connections; /*A linked list of our connections*/
  726.  
  727. /*
  728. Packet header:
  729. ####################################/
  730. # Dest  # Source#   Data size   #  /   data comes here
  731. ###################################\
  732.  1 byte  1 byte    2 bytes
  733.  
  734. If the sestination field is zero, we are initiating a new connection
  735. If the source field we are dropping a connection
  736. If both the destination and the source is zero, it is a Myping packet.
  737. */
  738.  
  739. void ctrlC(int sig)
  740. {
  741.   fprintf(log,"Shutting down the hard way\n");
  742.   shutdown(tunnel_sock,2);
  743.   close(tunnel_sock);
  744.   exit(-1);
  745. }
  746.  
  747.  
  748. char *get_ip(char *host){
  749.   struct hostent *remote;
  750.   struct in_addr *in;
  751.   remote=gethostbyname(host);
  752.   if(remote==NULL){
  753.     fprintf(log,"Hostinformation of remote machine '%s' not resolved,"\
  754.         " reason:%s",host,strerror(errno));
  755.     exit(-1);
  756.   }
  757.   in=(struct in_addr *)remote->h_addr_list[0];
  758.   return(strdup(inet_ntoa(*in)));
  759. }
  760.  
  761. int transmit_tunnel(char *data,int size,int source,int destination){
  762.   int nleft=size+4,nwritten;
  763.   fd_set selector,errsel;
  764.   data[0]=(unsigned char)destination; /*Destination into header*/
  765.   data[1]=(unsigned char)source;      /*Source into header*/
  766.   *((u_short *)&data[2])=htons(size); /*Size into header*/
  767.   while(nleft>0){
  768.     FD_ZERO(&errsel);
  769.     FD_ZERO(&selector);
  770.     FD_SET(tunnel_sock,&errsel);
  771.     FD_SET(tunnel_sock,&selector);
  772.     select(tunnel_sock+1,NULL,&selector,&errsel,NULL);
  773.     if(FD_ISSET(tunnel_sock,&errsel)){
  774.       printf("Big bug\n");
  775.     }
  776.     nwritten=write(tunnel_sock,data,nleft);
  777.     if(nwritten==-1){
  778.       fprintf(log,"Error writing to tunnel:%s\n",strerror(errno));
  779.       tunnel_sock=-1;
  780.       return(nwritten);
  781.     }
  782.     else if(nwritten==0){
  783.       fprintf(log,"Error: Wrote zero bytes in transmit_tunnel\n");
  784.       return(nwritten);
  785.     }
  786.     nleft-=nwritten;
  787.     data+=nwritten;
  788.   }
  789.   return(size - nleft);
  790. }
  791.  
  792. int receive_tunnel(){
  793.   static int received=0;
  794.   int n,left,got=0,quit=0,sofar=0;
  795.   received++;
  796.   while(sofar<4){
  797.     quit=0;
  798.     while(!quit){
  799.       n=read(tunnel_sock,&tunnel_buf[sofar],4-sofar);
  800.       if(n>0){quit=1;sofar+=n;}
  801.       if(n<1){
  802.     fprintf(log,"Connection terminated!\n");
  803.     shutdown(tunnel_sock,2);
  804.     close(tunnel_sock);
  805.     tunnel_sock=-1;
  806.     return(-1);
  807.       }
  808.     }
  809.   }
  810.   tunnel_des=tunnel_buf[0]; /*Fetch the destination*/
  811.   tunnel_src=tunnel_buf[1]; /*Fetch the source*/
  812.   tunnel_size=ntohs(*((u_short *)&tunnel_buf[2])); /*Fetch the size*/
  813.   left=tunnel_size;
  814.   while(left!=0){ 
  815.     n=read(tunnel_sock,&tunnel_buf[got],left);
  816.     if(n<0){
  817.       fprintf(log,"Connection terminated in receive_tunnel!\n");
  818.       shutdown(tunnel_sock,2);
  819.       close(tunnel_sock);
  820.       tunnel_sock=-1;
  821.       return(-1);
  822.     }
  823.     got+=n;
  824.     left-=n; 
  825.   } 
  826.   return(n);
  827. }
  828. void check_local_connections(fd_set *selector,fd_set *errsel,struct connection *con){
  829.   /*Here we check each of the local connections for incoming date*/
  830.   char buf[MAXLEN*2];
  831.   int i,n;
  832.   con=connections.head;
  833.   for(i=0;i<connections.num&&con;i++,con=con->next){
  834.     if(FD_ISSET(con->local_sock,errsel)){
  835.     fprintf(log,"LLocal connection terminated\n");
  836.     fprintf(log,"Removing connection to %s %d\n",con->host,con->port);
  837.     if(con->remote_sock) transmit_tunnel(buf,0,0,con->remote_sock);
  838.     removeconnection(con);
  839.     break;
  840.     }
  841.     if(FD_ISSET(con->local_sock,selector)&&con->remote_sock){
  842.       n=read(con->local_sock,&buf[4],MAXLEN);
  843.       if(n<1){
  844.     fprintf(log,"Local connection terminated\n");
  845.     fprintf(log,"Removing connection to %s %d\n",con->host,con->port);
  846.     transmit_tunnel(buf,0,0,con->remote_sock);
  847.     removeconnection(con);
  848.     break;
  849.       }
  850.       /*forward the data to the tunnel*/
  851.       transmit_tunnel(buf,n,con->local_sock,con->remote_sock);
  852.     }
  853.   }
  854. }
  855.  
  856. void ZERO(char * buf,int size){int i=0;while(i<size)buf[i++]=0;}
  857.  
  858. int writen(int fd, char *ptr, int nbytes)
  859. {
  860.   int nleft=nbytes,nwritten;
  861.   while(nleft>0){
  862.     nwritten=write(fd,ptr,nleft);
  863.     if(nwritten<=0) return(nwritten);
  864.     nleft-=nwritten;
  865.     ptr+=nwritten;
  866.   }
  867.   return(nbytes - nleft);
  868. }
  869.  
  870. int remote_connect(char *machine,int port)
  871. {
  872.   int sock;
  873.   struct sockaddr_in ser;
  874.   ZERO((char *) &ser,sizeof(ser));
  875.   ser.sin_family      = AF_INET;
  876.   ser.sin_addr.s_addr = inet_addr(machine);
  877.   ser.sin_port        = htons(port);
  878.   sock=socket(AF_INET,SOCK_STREAM,0);
  879.   if(sock==-1){perror("Error opening socket\n");return(-1);}
  880.   if(connect(sock,(struct sockaddr *) &ser,sizeof(ser))==-1){
  881.     fprintf(log,"Can't connect to server:%s\n",strerror(errno));
  882.     return(-1);
  883.   }
  884.   return(sock);
  885. }
  886.  
  887. void disconnect(struct connection *con,int sock1,int sock2){
  888.   fprintf(log,"Closing link to: %s %d\n",con->host,con->port);
  889.   shutdown(sock1,2);
  890.   shutdown(sock2,2);
  891.   close(sock1);
  892.   close(sock2);
  893.   close(con->local_sock);
  894. }
  895.  
  896. void init_descriptors(){
  897.   int i;
  898.   for(i=0;i<DESC_MAX;i++){
  899.     descriptors[i]=NULL;
  900.   }
  901. }
  902.  
  903. void removeconnection(struct connection *con){
  904.   struct connection *c2,*c=connections.head;
  905.   if(c==con){
  906.     connections.head=c->next;
  907.     descriptors[c->local_sock]=NULL;
  908.     free(c->host);
  909.     shutdown(c->local_sock,2);
  910.     close(c->local_sock);
  911.     free(c);
  912.     connections.num--;
  913.     return;
  914.   }
  915.   c2=c;
  916.   c=c->next;
  917.   while(c){
  918.     if(c==con){
  919.       /* connections.head=c2; */
  920.       c2->next=c->next;
  921.       descriptors[c->local_sock]=NULL;
  922.       free(c->host);
  923.       shutdown(c->local_sock,2);
  924.       close(c->local_sock);
  925.       free(c);
  926.       connections.num--;
  927.       return;
  928.     }
  929.     c2=c;
  930.     c=c->next;
  931.   }
  932. }
  933. <-->
  934. <++> tunnel/share.h
  935. /*********************/
  936. /* Structs & Defines */
  937. /*********************/
  938. #define MAX_HOSTNAME_SIZE 128
  939. #define MAXLEN 32768  /*Maximum length of our data*/
  940. #define ALIVE_TIME 60 /*Time to wait before sending a Myping*/
  941. #define DESC_MAX 128  /*Maximum number of descriptors used*/
  942. #define RETRY_TIME 60 /* Time to wait before we reconnect to portal*/
  943. #define max(a,b) ((a>b)?a:b)
  944. #define min(a,b) ((a<b)?a:b)
  945. #define AUTHOR "bishnu@hotmail.com"
  946.  
  947. struct connections{
  948.   int num;
  949.   struct connection *head;
  950. };
  951.  
  952. struct connection{
  953.   struct connection *next;
  954.   int port;
  955.   int local_sock;
  956.   int remote_sock;
  957.   time_t time;
  958.   char *host;
  959. };
  960.  
  961.  
  962. char *get_ip(char *host);
  963.  
  964. void random_delay(int n);
  965. int transmit_tunnel(char *data,int size,int source,int destination);
  966. int receive_tunnel();
  967. void hostname(char *name); 
  968. void ZERO(char * buf,int size);
  969. int writen(int fd, char *ptr, int nbytes);
  970. void ctrlC(int sig);
  971. void sleep_usec(int n);
  972. void    nonblock(int s);
  973. int remote_connect(char *machine,int port);
  974. void disconnect(struct connection *con,int sock1,int sock2);
  975. void init_descriptors();
  976. int max_descriptor();
  977. void removeconnection(struct connection *con);
  978. void check_local_connections(fd_set *selector,fd_set *errsel,struct connection *con);
  979. <-->
  980.  
  981.  
  982. ----[  EOF
  983.  
  984.