湘潭大学信息安全课作业答案2

湘潭大学信息安全课作业答案2
教师：李澄清院长
整理自助好心的助教大哥—申哥。
代码答案等来自19级各位同学，与网上流传的参考答案不一致，仅供参考

1.在信息安全领域，柯克霍夫斯原则(Kerckhoffs’Principle)就像是母亲和苹果派(译者注:美语中的一种比喻，说明某个原则或价值观显而易见并获得普遍认同)，并且完全卷在了一起。
a.请给出柯克霍夫斯原则在加密技术领域的定义。
b.请举出一个真实世界中违背柯克霍夫斯原则的例子，并说明其中是否导致了某些安全问题?
c.有时，柯克霍夫斯原则的应用更为广泛，甚至超出了它原本严格的密码技术相关定义。请给出一个柯克霍夫斯原则应用得更为广泛的定义。
答：
a：即使密码系统的任何细节已为人悉知，只要密匙（key，又称密钥）未泄漏，它也应是安全的。
b：对称加密。一旦一方的密钥泄露，那么加密信息就不再安全。
c：埃里克·雷蒙则将它引伸到开放源代码软件，称一套未假定敌人可获得源代码的信息安全软件并不可靠，因此，“永无可信的封闭源码”。反过来说，开放源码比封闭源码更安全。此种论点称为透明式的安全（security through transparency）。
2. Edgar Allan Poe于1843年发表的短篇小说《金甲虫》特别描述了一次密码分析攻击。
a．请问，其中破解的密码方案是什么类型的?具体是怎么破解的?
b.请问，这次密码分析攻击成功的后果如何?
答：
a：密码属于字母替换。
具体破解方式：
1.先推测密文的原文是英语
2.统计密文中各个字符出现的次数，并把出现次数最多的字符假设为字母“e”代入。
3.依据常见的含字母“e”的单词代入密文，再依次套用直到破译密码。
b:
后果：得到了密文：“一面好镜子在肖甫客店魔椅——四十一度十三分—— 东北偏北——最大树枝第七根桠枝东面——从骷髅头左眼射击—一从树前引一直距线通过子弹延伸五十英尺”。并且男主和他朋友通过密文找到了海盗埋藏的宝藏。
3. 假设使用凯撒密码加密，请找出与下面密文信息相对应的明文：VSRQJHEREVTXDUHSDQWU
答：明文：SpongeBob SqurePuats
4. 给定如下密文信息,请找出对应的明文和密钥:CSYEVIXIVQMREXIH提示:密钥是常规字母表的位移偏移量。
答：移位是右移22个，明文是“you are terminated”。
5. 假设我们拥有一台计算机，每秒钟能够执行240个密钥的测试。
a.如果密钥空间的大小为288，那么通过穷举式密钥检索找到密钥，预计需要多长时间(以年为单位)?
答：预计约为4.462 x106年
b.如果密钥空间的大小为212,那么通过穷举式密钥检索找到密钥,预计需要多长时间(以年为单位)?
答：预计为74.872 x1012年
c. 如果密钥空间的大小为256,那么通过穷举式密钥检索找到密钥，预计需要多长时间》(以年为单位)?
答：预计为1.67x1057年
7. 1876年美国总统大选中那个比较弱的加密使用的方案是：局部的电报密码本辅以单词级的置换，修改这个方案以便能使其更加安全
答：为了增加译码的难度，我们可以在凯撒移位密码里加入关键词。首先，将关键词放在字母表的开头，然后按照顺序完成字母表中剩余部分，从关键词的最后一个字母开始，省略用过的字母。比如以“look”为关键词，把它放在密码的字母表开头，因为要省略用过的字母，“look”只能写为“look”，并且后面的字母表中的“O”也要一并省去，即：
明码表：ABCDEFGHIJKLMN
密码表：LOKLMNPQRSTUVW
这种密码提供了超过N种的可能性，这样就不会被轻易试出密码啦。
8． 下面的问题有助于理解扰乱和扩散的概念。
a．请给出密码学技术领域使用的术语“扰乱”和“扩散”的定义。
b.在本章中讨论的经典加密技术中，哪些仅仅使用了扰乱原则?
c.在本章中讨论的经典加密技术中，哪些仅仅使用了扩散原则?
d.在本章中讨论的经典加密技术中，哪些同时使用了扰乱原则和扩散原则?
答：
a. 扰乱定义为混淆铭文和密文之间的相关性。扩散定义为一种将明文中的统计特性扩散并使其湮没于整个密文之中
b. 简单替换密码和一次性密码本加密都仅仅利用了扰乱原则。
c. 仅用了扩散原则：双换位密码；
d. 同时使用扰乱原则和扩散原则：电报密码。
9. 恢复出第22页所示的简单替换密码例子中的明文和秘钥。
秘钥：QGZAFOLBVMKJYWTCRHXPDUENIS
明文：
“The time has come,” the Walrus said,
"To talk of many things:
Of shoes—and ships-and sealing wax—
Of cabbages–—and kings—
And why the sea is boiling hot—
And whether pigs have wings.”
“But wait a bit,” the Oysters cried,
“Before we have our chat;
For some of us are out of breath,And all of us are fat!”
“No hurry!” said the Carpenter.They thanked him much for that.
"A loaf of bread,"the Walrus said,
“Is what we chiefly need:
Pepper and vinegar besides
Are very good indeed—
Now,if you’re ready, Oysters dear,
We can begin to feed.”
10. 确定与本章开头引用的在《爱丽丝漫游仙境》中出现的那段密文对应的明文和密钥。提示:该消息是用一种简单替换密码方法加密的，而且明文中没有空格和标点符号。
答：
MXDXBVTZWVMXNSPBQXLIMSCCSGXSCJXBOVQXCJZMOJZCVCTVWJCZAAXZBCSSCJXBQCJZCOJZCNSPOXBXSBTVWJCJZDXGXXMOZQMSCSCJXBOVQXCJZMOJZCNSPJZHGXXMOSPLHJZDXZAAXZBXHCSCJXTCSGXSCJXBOVQX

根据字符串中各字母的出现频率相比对，之后进行修正可得。
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ZGYHXIWJVKULTMSARBQCPDOENF
Never imagine yourself not to be otherwise than what it might appearto others that what you were or might have been was not otherwise than what youhad been would have appeared to them to be otherwise.
11.
密文为：
The United States was at peace with that nation and at the solicitation of Japan was still in conversation with its government and its emperor looking toward the maintenance of peace in the Pacific. Indeed, one hour after Japanese air squadrons had commenced bombing in Oahu, the Japanese ambassador to the United States and his colleague delivered to the Secretary of State a formal reply to a recent American message. While this reply stated that it seemed useless to continue the existing diplomatic negotiations it contained no threat or hint of war or armed attack.
密钥为：
KFAZSROBCWDINUELTHQGXVPJMY
12. 编写一个程序，帮助密码分析专家解密简单替换密码。该程序需要以密文作为输入，计算字母的出现频率，并显示出来给密码分析专家们看。另外，该程序还应该允许密码分析专家们猜测密钥，并进而能够显示使用该假定密钥“解密”消息后得到的对应的输出结果。
答：
C语言代码：
#include<stdio.h>
#include<string.h>
const int N=1e3+100;
char str[N],str2[N];
int len;
int num[N],mp[N];
//输出字符频率
void solve1(){
len=strlen(str+1);
for(int i=1;i<=len;i++){
num[str[i]]++;
}
printf(“字符频率：\n”);
for(int i=1;i<=‘z’;i++){
if(num[i]!=0){
printf(“%c: %d个, %f占比\n”,i,num[i],1.0*num[i]/len);
}
}
}
//猜测密钥 输出对应明文
void solve2(){

printf("请输入密钥:\n");
int cnt=0;
for(int i='A';i<='Z';i++){
    if(num[i]!=0){
        cnt++;
        printf("%c",i);
        mp[i]=cnt;
    }
}
for(int i='a';i<='z';i++){
    if(num[i]!=0){
        cnt++;
        printf("%c",i);
        mp[i]=cnt;
    }
}
printf("\n");
for(int i=1;i<=cnt;i++){
    printf("|");
}
printf("\n");

scanf("%s",str2+1);

printf("对应明文:\n");
for(int i=1;i<=len;i++){
    int temp=str[i];
    if(mp[temp]!=0)str[i]=str2[mp[temp]];
}
printf("%s\n\n ",str+1);

}
int main(){
while(printf(“请输入密文：\n”),scanf(“%s”,str+1)!=EOF){
memset(num,0,sizeof(num));
memset(mp,0,sizeof(mp));
solve1();
solve2();
}
}
测试：
以教材例子作为测试用例

对照发现出现错误，而错误出现在教材给的例子上，正确的密文应该是：
IRXUVFRUHDQGVHYHQBHDUVDJR
代入程序测试

结果正确
13.扩展思考题12中描述的程序，以便能够初步尝试对消息进行解密。一种合理的破解推进途径是:使用计算所得的字母频率统计和已知的英语语言字母频率统计，对密钥进行初步猜解。然后，从假定的解密结果中，统计其中呈现出来的字典词汇的个数并将其作为得分。接下来，对密钥中的每个字母，尝试将其与相邻的字母(指在频率统计排列的意义上)进行交换，再重新计算得分。如果得分有所提升，就更新该密钥为新的猜测值;如果得分没有提高，就不改变猜解的密钥。继续重复这个过程，直到完整地遍历字母表后得分不再提高为止。至此，你将可以为密码分析专家们展示出你的推测和解密。为在手工计算阶段帮助密码分析专家们，你的程序必须能确保思考题12中的各项程序功能运行正常。
编程代码如下：

-- coding: UTF-8 --

from ngram_score import ngram_score
print(“正在加载字典”)
fitness = ngram_score(‘english_quadgrams.txt’)

事实中的字母出现的权重

letter_frequency = {‘A’: 8.55, ‘K’: 0.81, ‘U’: 2.68, ‘B’: 1.60, ‘L’: 4.21,
‘V’: 1.06, ‘C’: 3.16, ‘M’: 2.53, ‘W’: 1.83,
‘D’: 3.87, ‘N’: 7.17, ‘X’: 0.19,
‘E’: 12.10, ‘O’: 7.47, ‘Y’: 1.72,
‘F’: 2.18, ‘P’: 2.07, ‘Z’: 0.11,
‘G’: 2.09, ‘Q’: 0.10,
‘H’: 4.96, ‘R’: 6.33,
‘I’: 7.33, ‘S’: 6.73,
‘J’: 0.22, ‘T’: 8.94
}

定义密文中的字母出现count

cipher_frequency = {‘A’: 0, ‘K’: 0, ‘U’: 0, ‘B’: 0, ‘L’: 0,
‘V’: 0, ‘C’: 0, ‘M’: 0, ‘W’: 0,
‘D’: 0, ‘N’: 0, ‘X’: 0,
‘E’: 0, ‘O’: 0, ‘Y’: 0,
‘F’: 0, ‘P’: 0, ‘Z’: 0,
‘G’: 0, ‘Q’: 0,
‘H’: 0, ‘R’: 0,
‘I’: 0, ‘S’: 0,
‘J’: 0, ‘T’: 0
}
def ArrayToStr(array):
return ‘’.join(i for i in array)

class SimpleSub:
parentkey = list(‘ABCDEFGHIJKLMNOPQRSTUVWXYZ’)
maxtimes = 1000
index = 0
stride = 1
parentscore = -99e9

# 计算密文中的字母出现频率
def count(self):
    for a in self.ciphertext:
        t = cipher_frequency[a]
        cipher_frequency.update({a: t + 1})
    print("1", cipher_frequency)

# 初步猜解 通过与现实中的字母出现频率， 与密文中的字母频率 依依匹配。
def pre_exchange(self):
    self.le_frequency = sorted(letter_frequency.items(), key=lambda x: x[1], reverse=False)
    self.ci_frequency = sorted(cipher_frequency.items(), key=lambda y: y[1], reverse=False)
    for i in range(26):
        self.parentkey[ord(self.ci_frequency[i][0]) - ord('A')] = self.le_frequency[i][0]
    print("实际中统计的字母出现概率:", self.le_frequency)
    print("密文中字母的出现概率统计：", self.ci_frequency)
    self.printK()

# 初步猜解
def pre_guess(self):
    self.count()
    self.pre_exchange()
    plaintext = self.decipher(self.parentkey)
    self.parentscore = fitness.score(plaintext)
    print("current score :", self.parentscore)
    print("plaintext:", plaintext)

def __init__(self, ciphertext):
    self.times = 0
    self.ciphertext = ciphertext

# 打印猜测的明文
def decipher(self, key):
    plaintext = ''
    key = ArrayToStr(key)
    for i in self.ciphertext:
        plaintext += self.parentkey[ord(i) - ord('A')]

    return plaintext

# 打印匹配表
def printK(self):
    print("---------------------")
    for i in range(26):
        print('  ', chr(i + 65), '-->', self.parentkey[i], end='')
        print()
    print("current k： ", ArrayToStr(self.parentkey))

# 按频率排序 两两之间交换 （先从频率低的开始交换）
# 假如按排序是这样的匹配
# Y  -->  P ，Z  -->  Y
# 交换之后有：
#  Y  -->  Y , Z--> P

def exchange_by_frequency(self):
    self.childkey = self.parentkey[:]
    c2 = 0

    while True:
        #print(self.index ," ",self.stride)
        if (self.stride >= 26): break

        elif (self.index + self.stride > 25):
            self.index = 0
            self.stride += 1
            continue
        c2 = self.index + self.stride

        self._le_frequency = self.le_frequency[:]
        self._ci_frequency = self.ci_frequency[:]

        # try 尝试交换两两
        self._ci_frequency[self.index], self._ci_frequency[c2] = self._ci_frequency[c2],self._ci_frequency[self.index]

        for i in range(26):
            self.childkey[ord(self.le_frequency[i][0]) - ord('A')] = self.ci_frequency[i][0]

        plaintext = self.decipher(self.childkey)
        score = fitness.score(plaintext)

        if score > self.parentscore:
            # print score
            self.index = 0
            self.stride = 0
            self.parentscore = score
            self.parentkey = self.childkey[:]
            self.le_frequency = self._le_frequency[:]
            self.ci_frequency = self._ci_frequency[:]
            self.printK()
            plaintext = self.decipher(self.parentkey)
            print("palinttext: ", plaintext)
            print(score)
            print('------------------------------------------------------------')
        self.index += 1

if name == “main”:
ciphertext = input(“请输入要破解的密文:”)
DecipherObj = SimpleSub(ciphertext)
print(‘测试’)
DecipherObj.pre_guess()
DecipherObj.exchange_by_frequency()

结果：
GKGSQKUZBCQAEIISKOXSZSICVSHSZGEGBSQSAHSGKHMERQGKGSKREHNKIHSLIMGEKHSASUGKNSHCAKUNSQQKOSPBCISGBCQHSLIMQGKGSZGBKGCGQSSNSZXQSISQQGEAEUGCUXSGBSSJCQGCUOZCLIENKGCAUSOEGCKGCEUQCGAEUGKCUSZUEGBHSKGEHBCUGERPKHEHKHNSZKGGKAD

源代码：
public class HomeworkEncryption {
private char[][] cipher_matrix;//密文矩阵
private char[][] plain_matrix;//明文矩阵
private String cipher = “we are all together”;//密文
private String rule_row = “2413”;//行置换规则
private String rule_column = “3124”;//列置换规则

HomeworkEncryption() {
    cipher_matrix = new char[4][4];
    plain_matrix = new char[4][4];
    
    //密文矩阵赋值
    int current = 0;//目前字符串位置
    for(int i = 0;i < 4;i++) {
        for(int j = 0;j < 4;j++) {
            if(cipher.charAt(current) == ' ') {
                current++;
            }
            cipher_matrix[i][j] = cipher.charAt(current);
            current++;
        }
    }
    
    //测试密文矩阵输出
    System.out.println("密文矩阵如下：");
    for(int i = 0;i < 4;i++) {
        for(int j = 0;j < 4;j++) {
            System.out.print(cipher_matrix[i][j]);
        }
        System.out.println();
    }
    
    //双置换加密，明文矩阵赋值
    for(int i = 0;i < 4;i++) {
        for(int j = 0;j < 4;j++) {
            plain_matrix[Character.getNumericValue(rule_row.charAt(i))-1][Character.getNumericValue(rule_column.charAt(j))-1] = cipher_matrix[i][j];
        }
    }
    
    //明文输出
    System.out.println("加密后的明文如下：");
    for(int i = 0;i < 4;i++) {
        for(int j = 0;j < 4;j++) {
            System.out.print(plain_matrix[i][j]);
        }
    }
}
public static void main(String[] args) {
    // TODO Auto-generated method stub
    new HomeworkEncryption();
}

}
运行结果：

1. 将密文放入一个7×10的数组中。然后“there”的字母将全部出现在一行中（按字母顺序排列）。这是列排序的开始，一旦知道列，就可以很容易地确定行。 答案是：“有人说共产主义是未来的浪潮，让他们来柏林吧。” 16． 答：采用分而治之的方法，其要点为首先尝试撤销列排列。

解：先将明文attackatdawn置于3x4的数组中得
A T T A
C K A T
D A W N
将（1，2，3，4）->（2，3，1，4）得
T T A A
K A C T
A W D N
得密文TKATAWACDATN
再将密文TKATAWACDATN置于3x4的数组中得
T K A T
A W A C
D A T N
将（1，2，3，4）->（4，2，1，3）得
T K T A
C W A A
N A D T
得到最终密文TCNKWATADAAT
18. 基于表2-1中的字母编码方式，下面的两个密文消息是使用相同的一次性密码本加密的：
KHHLTK和 KTHLLE
请找出与每个消息对应的所有可能的明文，以及相应的一次性密码本。
答：”shriek”和”strike”这两个词很管用。也许解决这个问题的最好办法，就是找到所有可以由允许的字母组成的6个字母的字典单词。那么任何 XOR 与 KHHLTK XOR KTHLLE 相同的对都是可能的解。
19.基于表2-1中的字母编码方式，下面的密文消息使用一次性密码本进行加密:
KITLKE
a.如果明文是“thrill"，那么请问密钥是什么?
b.如果明文是“tiller”，那么请问密钥是什么?
答案：
由表可知KITLKE所对应的二进制码如下：
011 010 111 100 011 000
a.
t h r i l l
明文 111 001 101 010 100 100
密文 011 010 111 100 011 000
密钥 100 011 010 110 111 100
l k i s t l
所以密钥是lkistl
b.
t i l l e r
明文 111 010 100 100 000 101
密文 011 010 111 100 011 000
密钥 100 000 011 000 011 101
l e k e k r
所以密钥是lekekr
20.假如你有一条消息包含1024位，请设计一个方案，将64位长的密钥扩展为1024位的字符串，以便结果字符串可以与消息进行异或运算，就像执行一次性密码本加密。如此加密的结果是否和一次性密码本一样安全呢?对于任何一个与之类似的加密方案，是否有可能和一-次性密码本加密具有同样的安全性呢?
答：设x为64位密钥。一种方法是简单地重复x 16次，但是，这相当于使用一个一次性密码本16次，因此非常不安全。更好的方法是设计一个函数f，它产生一个64位的输出，并且使用x，f(x)，f(f(x))，当然，安全性将取决于函数f的选择。
21.请设计一个电报密码本加密方案，可以加密任何二进制分组，而不仅仅只限于加密特定单词。你的加密方案应该包含尽量多的各种可能的电报密码本，并通过密钥来决定加密(或解密)特定消息时使用哪一个密码本。讨论一下针对你的加密方案会存在哪些可能的攻击。
答：简单的方案是指定一个完整的密码本，然后给定一个密钥，将密钥与密文的所有元素进行异或运算。
存在的问题：对于消息字长为4位或8位等低位数密码本，这本来就是不安全的，对于消息字长64位的高位数密码本，这个方案来是不切实际的，因为不可能存储这么大的密码本。
22. 假定下面截取的是某个经典电报密码本加密方案中的一部分被解密的密码本片段。
123 once
199 or
202 maybe
221 twice
233 time
332 upon
451 a
请解密如下密文:
242,554,650,464,532,749,567
假设有如下附加序列用于加密该消息：
119,222,199, 231,333,547,346
答：
密文：Once upon a time or maybe twice
解法：
242-119=123 -> once
554-222=332 -> upon
650-199=451 -> a
464-231=233 -> time
532-333=199 -> or
749-547=202 -> maybe
567-346=221 -> twice
23.仿射密码是简单替换密码的一种类型，其中每一个字母都按照规则c=(ap+ b)mod26进行加密。此处p ,c , a以及b，每一个都是0至25之间的数字，其中p代表明文字母，c代表密文字母，a和b是常数。对于明文和密文，0对应“a”，1对应“b”，以此类推。考虑使用仿射密码加密后产生的密文QJKES REOGH GXXRE OXEO，请确定常数a和b，并解密该消息。提示：明文字母“t”加密密文变成密文字母“H”，明文字母“o”加密为密文字母“E”
解：
由提示可知：
a．7 = (19a + b) mod26
b．4 = (14a + b) mod26
由a—b式可知
3=5a mod 26，也就是说 a=(26*n+3）/5,且a是整数所以可知n=2+5k,故a=11+26x(其中n,k是整数)
将a=11+26x带入原来的式子得b=6+26y(其中y是整数)
取a=11，b=6带入得
a->G b->R c->C d->N e->Y f->J g->U h->F i->Q j->B
k->M l->X m->I n->T o->E p->P q->A r->L s->W t->H
u->S v->D w->O x->Z y->K z->V
再由这个参照表可知明文为if you bow atall bow low(既然低了头,干脆就多低点)
24.维格内尔加密法(Vigenere cipher)使用“n位偏移”序列的简单替换密码来加密，其中的偏移量使用关键词作为索引，“A”代表偏移0位，“B”代表偏移1位，依此类推。举个例子，如果关键词是“DOG”，那么第1个字母被加密时使用3位偏移量的简单替换密码，第2个字母使用14位偏移量的简单替换密码，第3个字母使用6位偏移量的简单替换密码，接下来该模式重复，即第4个字母加密时使用3位偏移量，第5个字母加密时使用14位偏移量，依此类推。请对如下密文进行密码分析，即设法确定该密文的明文和密钥。说明:这个特定的消息使用维格内尔密码加密，关键词是由3个字母组成的英文单词。
CTMYR DOIBS RESRR RIJYR EBYLD IYMLC cYQxS RRMLQ FSDXFOWFKT CYJRR IQZSM x
答案：
#include<stdio.h>
#include<string.h>
int main(){
char code[4];
int a,b,c,temp;
char context[200];
gets(code);//输入密钥
gets(context);//输入要破解的内容
int len=strlen(context)+1;
char context_v[len];
a=code[0]-97;
b=code[1]-97;
c=code[2]-97;
for(int i=0;i<strlen(context);i++){

    temp=context[i]-97;
    if(i%3 == 0){
        if(temp<a)
        context_v[i] = context[i]+26-a;
        else
        context_v[i] = context[i]-a;    
    }
    if(i%3 ==1){
        if(temp<b)
        context_v[i] = context[i]+26-b;
        else
        context_v[i] = context[i]-b;    
    }if(i%3 ==2){
        if(temp<c)
        context_v[i] = context[i]+26-c;
        else
        context_v[i] = context[i]-c;    
    }
}
printf("%d %d %d\n",a,b,c);
puts(context_v);
//ctmyrdoibsresrrrijyrebyldiymlccyqxsrrmlqfsdxfowfktcyjrriqzsmx

}

25．假设在行星Binary上,，书面语言使用的字母表只包含两个字母：X和Y。再假设再这样的Binarian语言中，字母X出现的时间占75%，而字母Y出现的时间占25%。最后假如你有两个Binarian语言的消息，其消息长度相等。
a． 假如你来比较这两条消息的对应字母，那需要多久时间才能够将这些字母匹配起来？
b． 假如这两条消息中的其中一条是简单替换密码加密的，其中字母X加密为Y，字母Y加密为X。现在你再来比较这两条消息（其中一条加密了，另一条没有加密）中对应的字母，又需要多少时间才能将这些字母匹配起来？
c． 假如这两条消息都使用简单替换密码进行加密，其中字母X加密为Y，字母Y加密为X。现在你再来比较这两条消息（两条消息都被加密了）中对应的字母，又需要多长时间才能够将这些字母皮匹配起来？
d． 假如换一种情况，你获得了两个随机产生的消息，同样是只使用了两个字母X和Y。如果你去比较这两条消息的对应字母，那么需要多久时间才能够将这些字母匹配起来？
e． 什么是重合指数法(Index of Coincidence，IC)?提示：请参见参考文献[148]中的例子。
f． 在维格内尔加密算法中，如何利用重合指数法确定关键词的长度(请参考思考题24中关于维格内尔加密算法的定义)？
解答：
a. XX的概率是3/4 3/4=0.5625,YY的概率是1/16=0.0625，所以匹配的总概率是0.625
b. 5两条消息，一条加密了，一条不加密，相同的百分比是0.625。
c. 相同的0.625。
d. 它们会在大约一半的时间里匹配。
e. 重合指数：是假设一门语言由n个字母构成，每个字母发生的概率为pi(1<= i <= n),则重合指数是指随机无放回的抽取其中两个随机字母，它们相同的概率。重合指数法是指选取了合适的重合指数a，利用模a同余的原则将一个明文足够长，密钥长度固定为a的多表代换密码分解为a组平移密码，然后改密码即可破解。
f. 猜测关键字的不同长度，并将每个对应的列视为不同的消息。当你猜测正确的长度时，每条消息“将被一个简单的替换加密，因此IC将与英语相同——当猜测不正确时，IC应该接近随机文本的IC。
26. 在本章，我们讨论了一种前向检索攻击.
a.请说明如何实施前向检索攻击。
b.请说明如何能够阻止针对公开密钥加密系统的前向检索攻击。
c.请说明为什么前向检索攻击不能用于破解对称密钥加密系统。
答：
a. 在截获了一段用Alice 的公开密钥加密的密文后，如果攻击者想猜测出给定的明文消息“是”或“不是”原来的明文，那么她可以用Alice 的公钥加密这些假定的明文消息。如果有某个明文匹配了该密文，那么该消息即被破解。这种攻击方式被称为前向检索。
b. 对于公开密钥加密，必须确保明文消息的空间足够大，以使攻击者不能够通过简单地加密所有可能的明文消息串来发起此类攻击行为。
c.对称密钥加密系统使用的是对称密钥加密，对称密钥加密使用的算法比较强大，且密钥是私有密钥，没有公开，即使分析人员拥有一些密文和生成密文的明文，也不能译出密文或者发现密钥。加密算法应足以抵抗已知明文类型的破译。所以基于密钥公开的明文破译如前向检索攻击是无法破解对称密钥加密系统的。
27.考虑“单向”函数h。然后，给定值y=h(x)，从y直接找到x是不可行的。请思考如下问题:
a.假设Alice可以计算y=h(x)，其中x是Alice的薪酬，单位是美元。如果Trudy得到了y，那么她如何能够确定Alice的薪酬x呢?提示:针对这个问题，使用前向检索攻击。
b.为什么你的攻击没有违背h的单向特性?
c.请问，Alice 如何能够防止此类攻击?我们假设Trudy 能够访问到函数h的输出，Trudy 也知道输入中包含了Alice的薪酬，并且 Trudy还了解输入的格式。另外，这里没有密钥可用，所以Alice不能够对输出的值进行加密。
答：a.Trudy为所有合理的薪资值x计算h（x）。当她找到一个给出所需哈希的值时，她就恢复了Alice的薪资。
b.我们知道一些可能的输入值，所以它限制了我们的搜索。
c.包括一个随机值r并计算散列，例如y=h（x，r）。然后Trudy必须同时猜测x和r，并且假设r是从足够大的空间中选择的，则前向搜索不再可行。
28.假设某个特定的加密方案使用40位的密钥，并且加密是安全的(尚未有已知的捷径攻击)。
a.平均而言，一次穷举式检索攻击需要多大的工作量?
b.假如可以获得已知明文，请列举一种攻击方案并说明其要点。
c.在仅知道密文的情况下，你将如何发起对该加密系统的攻击呢?
答案：
a、 平均来说，必须试一半的密钥，工作系数为2^39。
b、 已知明文攻击：执行全面的密钥搜索，并为每个假定的密钥“解密”相应的密文。当知道相应的明文时就能得到正确的密钥。
c、唯密文攻击，通过密文得到尽可能多的明文，或者推算出密钥，加密算法以解出更多的明文，这并不容易，因为需要做一些工作来判断什么时候拿到了正确的密匙。举个例子，如果你知道明文是英文的，原则上，你可以目测每一个假定的解密，直到你看到一个看起来像英文的，但这对于这么大的密钥空间是不切实际的。要使攻击自动化，你需要自动测试假定的解密以查看它们是否为英语，这需要一些额外的工作。
29.假设Alice用一种安全的加密方案加密了一条消息，该方案使用40位的密钥。Trudy知道密文和加密算法，但是她不知道明文和密钥。Trudy计划实施一次穷举式检索攻击，也就是说，她打算尝试每一个可能的密钥，直到她能够找到那个正确的密钥。请思考如下问题:
a，平均而言，Trudy在找到那个正确的密钥之前要尝试多少个密钥呢?
b. Trudy 如何才能够知道她找到了那个正确的密钥呢﹖注意:对于Trudy 来说，因为有太多的选择，所以不可能手工去检查每一个密钥，她必须有一些自动化的手段来判定假设的密钥正确与否。
c.在b的测试中，你的自动测试的工作量多大?
d.在b的测试中，你预计会有多少错误警报﹖也就是说，由不正确的密钥产生的假想
的解密结果能够通过测试的概率多大?
a. 正确的那个一半的键，也就是2^39个。
b.假设明文是英语，Trudy必须测试每个假定解密的“英语性”。这可以通过使用英语语言的基本统计来实现。
根据明文的大小，这可能会产生许多错误警报。
c.它取决于很多因素，但假设你解密m，计算专论和有向图统计，看看它与英语有多接近。对某个常数c，做功是c*2^35，你想让c变小。你可以通过减少解密的比特数让c变小，但解密的次数越少，通过测试的不正确密钥就越多，你很快就会厌倦查看不正确的“解密”。一个更好的策略是使用一个快速的主测试来清除大部分不正确的密钥，然后进行二次测试(例如，解密更多的明文并计算通过主测试的密钥的更多统计信息。然后您可以确定这些测试的最佳大小，从而使总体工作因素最小化
d.这取决于具体测试的细节，但总的想法，看c部分的答案。