密码学与网络安全-基本概念

安全方法

安全模型

1. 无安全性
2. 隐藏安全：一件事物不为人知，那么它是安全的。如密码。类比代码实现防范，路径，端口等。
3. 主机安全性
4. 网络安全性

安全管理

1. 向有关方面解释安全策略
2. 该要介绍每个人的责任
3. 建立可监察性
4. 提供预期和定期审查

安全原则

举例：
小李向小黄写了封求爱情书，由邮递员小张寄送，但不希望小张知道书中的内容。

四大原则：

1. 保密性（confidentiality）：其它人收到了加密的消息，但不会知道细节。
2. 完整性（integrity）：要保证小黄收到的消息没有被添油加醋（篡改）
3. 鉴别 (authentication)： 小黄要保证收到的书是小李寄来的，而不是老王（伪装小李）寄来的。
4. 不可抵赖（non-repudiation）：小黄收道后要避免小李反悔（反复无常是渣男的表现）。仲裁者要用定情信物（小李的签名）否认小李的抵赖。

针对整个系统的两个原则：
5. 访问控制（access control）：确定谁能访问什么。
6. 可用性（availability）：

攻击类型

攻击方法：

保密性（confidentiality）~截获（interception）: 例如网络抓包
完整性（integrity）~篡改（modification）：数据内容是否完整。
鉴别 (authentication)~伪造（fabrication）：数据的来源是否正确。
不可抵赖（non-repudiation）：防止发消息的人否认，如银行转账者。
可用性（availability）~ 中断（interruption） 如饱和攻击造成拒绝服务（Denial of Service, DOS）。

1. 被动攻击（passive attacks）:监听截获但不会对数据进行修改。
   a. 消息内容泄漏
   b. 通信量分析(Taffic analysis)
2. 主动攻击（active attacks）：
   a. 中断
   b. 修改：重放攻击（replay attacks） 改变消息（alteration of messages）
   c. 伪造

特定攻击

数据包窃听(Packet sniffing / snooping) or IP sniffing
数据包伪装（Packet spoofing） or IP spoofing

伪装的几种情况

1. 截获答复, 发动劫持（hijacking）攻击
2. 攻击者不用看到答复：拒绝服务攻击。

病毒(virus)
特洛伊木马（Trojan horse)
蠕虫病毒（worm）

编程练习题

主要数字逻辑中

1. 编写一个程序， 包含字符串值"Hello World"， 分别将字符串的每个字符与 1 进行异或运算并显示结果，再将每个值与0异或，看看有什么特殊之处。
   代码如下：

   def show_xor(string:str, x:int):
       print("将%s 的每个字符与 %s (%s)的异或结果为：" % (string, x, bin(x)))
       xor = []
       for _ in string:
           print("{} {:4} {:10} {:4} {:10} {}".format(_, ord(_), bin(ord(_)),ord(_)^x, bin(ord(_)^x),chr(ord(_)^x)))
           xor.append(chr(ord(_)^x))
       print(string)
       print(''.join(xor))
   if __name__ == '__main__':
   	string = "Hello World"
       show_xor(string, 1)
       show_xor(string, 0)
   

   将Hello World 的每个字符与 1 (0b1)的异或结果为：
   H   72 0b1001000    73 0b1001001  I
   e  101 0b1100101   100 0b1100100  d
   l  108 0b1101100   109 0b1101101  m
   l  108 0b1101100   109 0b1101101  m
   o  111 0b1101111   110 0b1101110  n
       32 0b100000     33 0b100001   !
   W   87 0b1010111    86 0b1010110  V
   o  111 0b1101111   110 0b1101110  n
   r  114 0b1110010   115 0b1110011  s
   l  108 0b1101100   109 0b1101101  m
   d  100 0b1100100   101 0b1100101  e
   Hello World
   Idmmn!Vnsme
   将Hello World 的每个字符与 0 (0b0)的异或结果为：
   H   72 0b1001000    72 0b1001000  H
   e  101 0b1100101   101 0b1100101  e
   l  108 0b1101100   108 0b1101100  l
   l  108 0b1101100   108 0b1101100  l
   o  111 0b1101111   111 0b1101111  o
       32 0b100000     32 0b100000    
   W   87 0b1010111    87 0b1010111  W
   o  111 0b1101111   111 0b1101111  o
   r  114 0b1110010   114 0b1110010  r
   l  108 0b1101100   108 0b1101100  l
   d  100 0b1100100   100 0b1100100  d
   Hello World
   Hello World
   

2. 编写一个程序， 包含字符串值"Hello World"，将每个字符与 127 进行 与 或 异或 运算并显示结果， 为什么结果不同？

   def show_xor(string:str, x:int):
       print("将%s 的每个字符与 %s (%s)的异或结果为：" % (string, x, bin(x)))
       xor = []
       for _ in string:
           print("{} {:4} {:10} {:4} {:10} {}".format(_, ord(_), bin(ord(_)),ord(_)^x, bin(ord(_)^x),chr(ord(_)^x)))
           xor.append(chr(ord(_)^x))
       print(string)
       print(''.join(xor))
   def show_and(string:str, x:int):
       print("将%s 的每个字符与 %s (%s)的与结果为：" % (string, x, bin(x)))
       and_ = []
       for _ in string:
           print("{} {:4} {:10} {:4} {:10} {}".format(_, ord(_), bin(ord(_)),ord(_)&x, bin(ord(_)&x),chr(ord(_)&x)))
           and_.append(chr(ord(_)&x))
       print(string)
       print(''.join(and_))
   
   def show_or(string:str, x:int):
       print("将%s 的每个字符与 %s (%s)的每个字符的或结果为：" % (string, x, bin(x)))
       or_ = []
       for _ in string:
           print("{} {:4} {:10} {:4} {:10} {}".format(_, ord(_), bin(ord(_)),ord(_)|x, bin(ord(_)|x),chr(ord(_)|x)))
           or_.append(chr(ord(_)|x))
       print(string)
       print(''.join(or_))
   if __name__ == '__main__':
       string = "Hello World"
       # show_xor(string, 1)
       # show_xor(string, 0)
       show_and(string, 127)
       show_or(string, 127)
       show_xor(string, 0)
   

   将Hello World 的每个字符与 127 (0b1111111)的与结果为：
   H   72 0b1001000    72 0b1001000  H
   e  101 0b1100101   101 0b1100101  e
   l  108 0b1101100   108 0b1101100  l
   l  108 0b1101100   108 0b1101100  l
   o  111 0b1101111   111 0b1101111  o
       32 0b100000     32 0b100000    
   W   87 0b1010111    87 0b1010111  W
   o  111 0b1101111   111 0b1101111  o
   r  114 0b1110010   114 0b1110010  r
   l  108 0b1101100   108 0b1101100  l
   d  100 0b1100100   100 0b1100100  d
   Hello World
   Hello World
   将Hello World 的每个字符与 127 (0b1111111)的每个字符的或结果为：
   H   72 0b1001000   127 0b1111111  
   e  101 0b1100101   127 0b1111111  
   l  108 0b1101100   127 0b1111111  
   l  108 0b1101100   127 0b1111111  
   o  111 0b1101111   127 0b1111111  
       32 0b100000    127 0b1111111  
   W   87 0b1010111   127 0b1111111  
   o  111 0b1101111   127 0b1111111  
   r  114 0b1110010   127 0b1111111  
   l  108 0b1101100   127 0b1111111  
   d  100 0b1100100   127 0b1111111  
   Hello World
   
   将Hello World 的每个字符与 0 (0b0)的异或结果为：
   H   72 0b1001000    72 0b1001000  H
   e  101 0b1100101   101 0b1100101  e
   l  108 0b1101100   108 0b1101100  l
   l  108 0b1101100   108 0b1101100  l
   o  111 0b1101111   111 0b1101111  o
       32 0b100000     32 0b100000    
   W   87 0b1010111    87 0b1010111  W
   o  111 0b1101111   111 0b1101111  o
   r  114 0b1110010   114 0b1110010  r
   l  108 0b1101100   108 0b1101100  l
   d  100 0b1100100   100 0b1100100  d
   Hello World
   Hello World
   

结论

主要考察逻辑运算（布尔运算）的基本性质。这种性质在密码学中应用广泛。
通过程序的输出不难看出几点性质：
按位异或的3个特点:

1. 任何数与 0 异或 都等于 任何数。（若是0 变为0， 若是1 变为1）
2. 任何数与 1 异或 都等于 该数取反（若是0 变为1， 若是1 变为0）
3. 任何数与 它自己 异或 都等于 0。（若是0 变为0， 若是1 变为0）

按位与的特点：
0 & 1 = 0
1 & 1 = 1

按位或的特点：
0 | 1 = 1
1 | 1 = 1