使用位运算符解密隐藏消息
Decrypt Hidden Message with bitwise operator
我遇到了这个练习，它要求你解密下图中加密代码中的隐藏消息。
这个练习与按位运算符有关，所以我假设我们需要使用“异或”运算符来解密具有 00 到 99 的 2 位密钥的代码。
这是我的代码。
char input[9] = "dEsxDI^I" , decrypt[9]; // Variable Declarations and Initializations.
int key;
printf("\n\n\nDecrpytion for the Encrypted code \"dEsxDI^I\" :\n\n\n");
for(key = 0 ; key <= 99 ; key++) // 00 to 99 Key Testing.
{
for (int i = 0; i < 8; i++) // Decryption Process.
{
decrypt[i] = input[i] ^ key;
printf("%c", decrypt[i]);
}
printf(" = Key No (%d)\n\n\n", key); // Displays Key No for each decryption.
}
printf("\n\n");
return 0;
我解密的消息是“Hi_There”，加密密钥是“44”。
只是想知道它是否正确？因为这是我解密的所有消息中最合乎逻辑的消息。
没有为这个练习提供解决方案，所以我很好奇。
那么，你们的输出是多少？
我对你的解密消息进行了 XOR、~XOR、AND、NAND、OR、NOR、左移、右移运算。
很自然地，我们中的任何一个人都会认为答案的关键是 44。
我没有从该字符串中收到任何其他可读消息。
虽然如果你考虑所有的可能性:
异或：
- 键 12 :
hItHERE
- 键 44 :
Hi_There
- 键 112 :
49.9____
用 spaces 替换下划线（不是不可打印的字符，只是空 space）
或：
- 键 14 :
no~no~o
- 键 46 :
no~no~o
是的，它们都是一样的，事实上 OR 会产生很多带有重复字符的字符串，例如 '{{{{{{{{'
~异或：
- 键 243：
hItHERE
- 键 211：
Hi_There
现在可读消息的定义取决于每个人。
hItHERE可能是空中打击的标志。
no~no~o 可能是求助电话或否认某事。
49.9 可能是生物武器实验室中某种秘密成分的数量。
0~99是一个相当有限的范围。
The message I decrypted is " Hi_There " with the encryption key of "
44 ". Just wondering is it the correct message or not?
对于 8 字符密码的解决方案是否必须是 8 字符解决方案，没有明确的指示，但这是一般情况。如果没有明确的说明（“您的解决方案可能包含也可能不包含密码中的所有字符。”），我会寻找包含 8 个字符的解决方案。
虽然您没有提供代码的细节，但对所有可能的键进行简单的暴力循环与其他任何方法一样好。由于未向您提供解决方案，因此您无法在此过程中进行任何比较。您能做的最好的事情就是遍历所有密钥，将其应用于密码中的每个字符并输出结果——然后使用您 "good ole eyeballs" 来选择解决方案。 （如果您知道解决方案将是所有 upper/lower 个大小写字符——您可以在输出每个结果以进行 手动 检查之前强制执行该检查）。
不清楚您是否被告知对每个字符 XOR key，或者您是否应该尝试所有合理的按位运算，但一般的 OR 或XOR 是一个很好的起点。
将 XOR 放在一起，您可以做类似的事情：
#include <stdio.h>
int main (void) {
char *buf = "dEsxDI^I";
for (int key = 0; key < 100; key++) { /* loop over all keys */
char *p = buf; /* output key (and char) */
printf ("key: %2d ('%c') ", key, key >= ' ' ? key : 0);
while (*p) /* loop over all chars */
putchar (*p++ ^ key); /* output decrypted char */
putchar ('\n'); /* tidy up with '\n' */
}
return 0;
}
例子Use/Output
$ ./bin/keyfind2
key: 0 ('') dEsxDI^I
key: 1 ('') eDryEH_H
key: 2 ('') fGqzFK\K
key: 3 ('') gFp{GJ]J
key: 4 ('') `Aw|@MZM
key: 5 ('') a@v}AL[L
<snip>
key: 12 ('') hItHERE
<snip>
key: 43 ('+') OnXSobub
key: 44 (',') Hi_There
key: 45 ('-') Ih^Uidsd
<snip>
用XORappy到key上，用手动眼球扫描解法，key: 12 ('') hItHERE看起来很有希望，但只有7个字符的解法, 继续 key: 44 (',') Hi_There 提供了一个 8 个字符的解决方案，这将是两个答案中更好的一个。
所以，“是”，我认为您找到了正确的解决方案。
不使用字符串索引的指针
由于使用指针 p 遍历 buf 中的密码字符串似乎让您摸不着头脑（别担心，它会随着时间的推移全部吸收） ，您可以轻松地对字符串索引执行完全相同的操作。 for 循环与索引一起使用同样容易。消除指针并使用字符串索引，您可以执行以下操作：
#include <stdio.h>
int main (void) {
char *buf = "dEsxDI^I";
for (int key = 0; key < 100; key++) { /* loop over all keys */
printf ("key: %2d ('%c') ", key, key >= ' ' ? key : 0);
for (int i = 0; buf[i]; i++) /* loop over all chars */
putchar (buf[i] ^ key); /* output decrypted char */
putchar ('\n'); /* tidy up with '\n' */
}
return 0;
}
（输出完全一样）
关于在 printf 语句中使用 三元运算符 的问题对于不熟悉它的人来说是一个很好的问题。三元运算符是 if/else 语句的 shorthand，其中表达式的结果基于给定的测试条件。三元运算符本质上是：
condition ? if_true_value : if_false_value
在我的 printf 声明中，我只是这样做：
printf ("key: %2d ('%c') ", key, key >= ' ' ? key : 0);
显然，key 的整数值与 %2d 转换说明符一起使用，以确保所有 key 值都打印为两个字符宽（这就是 [=33= 的目的） ] field-width 说明符。现在让我们看看我想通过%c打印什么字符。
key >= ' ' ? key : 0 // huh?
很简单。第一个 printable ASCII 值是 0x20（十六进制）或 32 十进制，对应于 ' ' (space） 特点。请参阅下面的 ASCII table。那么我的测试条件是什么？如果 (key >= ' ') 大于或等于 space。如果是，就打印key代表的字符。如果不是，则打印 nul-character（十进制 0 或等价字符 '[=41=]' -- 这只是需要更多的输入）。你可以做同样的事情：
if (key >= ' ')
printf ("key: %2d ('%c') ", key, key);
else
printf ("key: %2d ('') ", key);
(就是多打字:)
ASCII Table
Char Dec Oct Hex | Char Dec Oct Hex | Char Dec Oct Hex | Char Dec Oct Hex
-------------------------------------------------------------------------------------
(nul) 0 0000 0x00 | (sp) 32 0040 0x20 | @ 64 0100 0x40 | ` 96 0140 0x60
(soh) 1 0001 0x01 | ! 33 0041 0x21 | A 65 0101 0x41 | a 97 0141 0x61
(stx) 2 0002 0x02 | " 34 0042 0x22 | B 66 0102 0x42 | b 98 0142 0x62
(etx) 3 0003 0x03 | # 35 0043 0x23 | C 67 0103 0x43 | c 99 0143 0x63
(eot) 4 0004 0x04 | $ 36 0044 0x24 | D 68 0104 0x44 | d 100 0144 0x64
(enq) 5 0005 0x05 | % 37 0045 0x25 | E 69 0105 0x45 | e 101 0145 0x65
(ack) 6 0006 0x06 | & 38 0046 0x26 | F 70 0106 0x46 | f 102 0146 0x66
(bel) 7 0007 0x07 | ' 39 0047 0x27 | G 71 0107 0x47 | g 103 0147 0x67
(bs) 8 0010 0x08 | ( 40 0050 0x28 | H 72 0110 0x48 | h 104 0150 0x68
(ht) 9 0011 0x09 | ) 41 0051 0x29 | I 73 0111 0x49 | i 105 0151 0x69
(nl) 10 0012 0x0a | * 42 0052 0x2a | J 74 0112 0x4a | j 106 0152 0x6a
(vt) 11 0013 0x0b | + 43 0053 0x2b | K 75 0113 0x4b | k 107 0153 0x6b
(np) 12 0014 0x0c | , 44 0054 0x2c | L 76 0114 0x4c | l 108 0154 0x6c
(cr) 13 0015 0x0d | - 45 0055 0x2d | M 77 0115 0x4d | m 109 0155 0x6d
(so) 14 0016 0x0e | . 46 0056 0x2e | N 78 0116 0x4e | n 110 0156 0x6e
(si) 15 0017 0x0f | / 47 0057 0x2f | O 79 0117 0x4f | o 111 0157 0x6f
(dle) 16 0020 0x10 | 0 48 0060 0x30 | P 80 0120 0x50 | p 112 0160 0x70
(dc1) 17 0021 0x11 | 1 49 0061 0x31 | Q 81 0121 0x51 | q 113 0161 0x71
(dc2) 18 0022 0x12 | 2 50 0062 0x32 | R 82 0122 0x52 | r 114 0162 0x72
(dc3) 19 0023 0x13 | 3 51 0063 0x33 | S 83 0123 0x53 | s 115 0163 0x73
(dc4) 20 0024 0x14 | 4 52 0064 0x34 | T 84 0124 0x54 | t 116 0164 0x74
(nak) 21 0025 0x15 | 5 53 0065 0x35 | U 85 0125 0x55 | u 117 0165 0x75
(syn) 22 0026 0x16 | 6 54 0066 0x36 | V 86 0126 0x56 | v 118 0166 0x76
(etb) 23 0027 0x17 | 7 55 0067 0x37 | W 87 0127 0x57 | w 119 0167 0x77
(can) 24 0030 0x18 | 8 56 0070 0x38 | X 88 0130 0x58 | x 120 0170 0x78
(em) 25 0031 0x19 | 9 57 0071 0x39 | Y 89 0131 0x59 | y 121 0171 0x79
(sub) 26 0032 0x1a | : 58 0072 0x3a | Z 90 0132 0x5a | z 122 0172 0x7a
(esc) 27 0033 0x1b | ; 59 0073 0x3b | [ 91 0133 0x5b | { 123 0173 0x7b
(fs) 28 0034 0x1c | < 60 0074 0x3c | \ 92 0134 0x5c | | 124 0174 0x7c
(gs) 29 0035 0x1d | = 61 0075 0x3d | ] 93 0135 0x5d | } 125 0175 0x7d
(rs) 30 0036 0x1e | > 62 0076 0x3e | ^ 94 0136 0x5e | ~ 126 0176 0x7e
(us) 31 0037 0x1f | ? 63 0077 0x3f | _ 95 0137 0x5f | (del) 127 0177 0x7f
目标应该是使检测机制自动化。与其从详尽的列表中找到解密的短语，不如形成代码。
对 OP 的代码进行一些小的修改，下面调用各种 valid() 来评估解密有效性。
建议OP进一步调整valid()直到提供1"best"解密。然后找到解密的"formula"
为了好玩：试着找到这个间谍的 phone 号码和 Google 来确定名字。她的加密数据是"0>?%=;81"。相应地调整 valid()。
#include <stdio.h>
#if 1
int valid(const char *decrypt) {
size_t end = strspn(decrypt, " ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz");
return end == 8;
}
#else
int valid(const char *decrypt) {
size_t end = strspn(decrypt, " ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz");
if (end != 8) return 0;
for (int i=1; i<8; i++) {
if (isupper(decrypt[i-1]) && isupper(decrypt[i])) { //reject paired capital letters
return 0;
}
}
return 1;
}
#endif
int main(void) {
const char input[9] = "dEsxDI^I";
printf("Decryption for the Encrypted code \"dEsxDI^I\" :\n\n");
for (int key = 0; key <= 99; key++) {
char decrypt[9] = ""; // Variable Declarations and Initializations.
for (int i = 0; i < 8; i++) {
decrypt[i] = (char) (input[i] ^ key);
}
if (valid(decrypt)) {
printf("Key No %2d Decrypt:<%s>\n", key, decrypt);
}
}
return 0;
}
输出 - 第一个 valid()
Decryption for the Encrypted code "dEsxDI^I" :
Key No 1 Decrypt:<eDryEH_H>
Key No 10 Decrypt:<nOyrNCTC>
Key No 11 Decrypt:<oNxsOBUB>
Key No 16 Decrypt:<tUchTYNY>
Key No 17 Decrypt:<uTbiUXOX>
Key No 22 Decrypt:<rSenR_H_>
Key No 28 Decrypt:<xYodXUBU>
Key No 29 Decrypt:<yXneYTCT>
Key No 39 Decrypt:<CbT_cnyn>
Key No 42 Decrypt:<NoYRnctc>
Key No 43 Decrypt:<OnXSobub>
Key No 44 Decrypt:<Hi_There>
Key No 48 Decrypt:<TuCHtyny>
Key No 49 Decrypt:<UtBIuxox>
Key No 60 Decrypt:<XyODxubu>
Key No 61 Decrypt:<YxNEytct>
输出 - 第二 valid()
Decryption for the Encrypted code "dEsxDI^I" :
Key No 22 Decrypt:<rSenR_H_>
Key No 39 Decrypt:<CbT_cnyn>
Key No 44 Decrypt:<Hi_There>
我遇到了这个练习，它要求你解密下图中加密代码中的隐藏消息。
这个练习与按位运算符有关，所以我假设我们需要使用“异或”运算符来解密具有 00 到 99 的 2 位密钥的代码。
这是我的代码。
char input[9] = "dEsxDI^I" , decrypt[9]; // Variable Declarations and Initializations.
int key;
printf("\n\n\nDecrpytion for the Encrypted code \"dEsxDI^I\" :\n\n\n");
for(key = 0 ; key <= 99 ; key++) // 00 to 99 Key Testing.
{
for (int i = 0; i < 8; i++) // Decryption Process.
{
decrypt[i] = input[i] ^ key;
printf("%c", decrypt[i]);
}
printf(" = Key No (%d)\n\n\n", key); // Displays Key No for each decryption.
}
printf("\n\n");
return 0;
我解密的消息是“Hi_There”，加密密钥是“44”。 只是想知道它是否正确？因为这是我解密的所有消息中最合乎逻辑的消息。
没有为这个练习提供解决方案，所以我很好奇。 那么，你们的输出是多少？
我对你的解密消息进行了 XOR、~XOR、AND、NAND、OR、NOR、左移、右移运算。
很自然地，我们中的任何一个人都会认为答案的关键是 44。
我没有从该字符串中收到任何其他可读消息。
虽然如果你考虑所有的可能性:
异或：
- 键 12 :
hItHERE - 键 44 :
Hi_There - 键 112 :
49.9____
用 spaces 替换下划线（不是不可打印的字符，只是空 space）
或：
- 键 14 :
no~no~o - 键 46 :
no~no~o
是的，它们都是一样的，事实上 OR 会产生很多带有重复字符的字符串，例如 '{{{{{{{{'
~异或：
- 键 243：
hItHERE - 键 211：
Hi_There
现在可读消息的定义取决于每个人。
hItHERE可能是空中打击的标志。
no~no~o 可能是求助电话或否认某事。
49.9 可能是生物武器实验室中某种秘密成分的数量。
0~99是一个相当有限的范围。
The message I decrypted is " Hi_There " with the encryption key of " 44 ". Just wondering is it the correct message or not?
对于 8 字符密码的解决方案是否必须是 8 字符解决方案，没有明确的指示，但这是一般情况。如果没有明确的说明（“您的解决方案可能包含也可能不包含密码中的所有字符。”），我会寻找包含 8 个字符的解决方案。
虽然您没有提供代码的细节，但对所有可能的键进行简单的暴力循环与其他任何方法一样好。由于未向您提供解决方案，因此您无法在此过程中进行任何比较。您能做的最好的事情就是遍历所有密钥，将其应用于密码中的每个字符并输出结果——然后使用您 "good ole eyeballs" 来选择解决方案。 （如果您知道解决方案将是所有 upper/lower 个大小写字符——您可以在输出每个结果以进行 手动 检查之前强制执行该检查）。
不清楚您是否被告知对每个字符 XOR key，或者您是否应该尝试所有合理的按位运算，但一般的 OR 或XOR 是一个很好的起点。
将 XOR 放在一起，您可以做类似的事情：
#include <stdio.h>
int main (void) {
char *buf = "dEsxDI^I";
for (int key = 0; key < 100; key++) { /* loop over all keys */
char *p = buf; /* output key (and char) */
printf ("key: %2d ('%c') ", key, key >= ' ' ? key : 0);
while (*p) /* loop over all chars */
putchar (*p++ ^ key); /* output decrypted char */
putchar ('\n'); /* tidy up with '\n' */
}
return 0;
}
例子Use/Output
$ ./bin/keyfind2
key: 0 ('') dEsxDI^I
key: 1 ('') eDryEH_H
key: 2 ('') fGqzFK\K
key: 3 ('') gFp{GJ]J
key: 4 ('') `Aw|@MZM
key: 5 ('') a@v}AL[L
<snip>
key: 12 ('') hItHERE
<snip>
key: 43 ('+') OnXSobub
key: 44 (',') Hi_There
key: 45 ('-') Ih^Uidsd
<snip>
用XORappy到key上，用手动眼球扫描解法，key: 12 ('') hItHERE看起来很有希望，但只有7个字符的解法, 继续 key: 44 (',') Hi_There 提供了一个 8 个字符的解决方案，这将是两个答案中更好的一个。
所以，“是”，我认为您找到了正确的解决方案。
不使用字符串索引的指针
由于使用指针 p 遍历 buf 中的密码字符串似乎让您摸不着头脑（别担心，它会随着时间的推移全部吸收） ，您可以轻松地对字符串索引执行完全相同的操作。 for 循环与索引一起使用同样容易。消除指针并使用字符串索引，您可以执行以下操作：
#include <stdio.h>
int main (void) {
char *buf = "dEsxDI^I";
for (int key = 0; key < 100; key++) { /* loop over all keys */
printf ("key: %2d ('%c') ", key, key >= ' ' ? key : 0);
for (int i = 0; buf[i]; i++) /* loop over all chars */
putchar (buf[i] ^ key); /* output decrypted char */
putchar ('\n'); /* tidy up with '\n' */
}
return 0;
}
（输出完全一样）
关于在 printf 语句中使用 三元运算符 的问题对于不熟悉它的人来说是一个很好的问题。三元运算符是 if/else 语句的 shorthand，其中表达式的结果基于给定的测试条件。三元运算符本质上是：
condition ? if_true_value : if_false_value
在我的 printf 声明中，我只是这样做：
printf ("key: %2d ('%c') ", key, key >= ' ' ? key : 0);
显然，key 的整数值与 %2d 转换说明符一起使用，以确保所有 key 值都打印为两个字符宽（这就是 [=33= 的目的） ] field-width 说明符。现在让我们看看我想通过%c打印什么字符。
key >= ' ' ? key : 0 // huh?
很简单。第一个 printable ASCII 值是 0x20（十六进制）或 32 十进制，对应于 ' ' (space） 特点。请参阅下面的 ASCII table。那么我的测试条件是什么？如果 (key >= ' ') 大于或等于 space。如果是，就打印key代表的字符。如果不是，则打印 nul-character（十进制 0 或等价字符 '[=41=]' -- 这只是需要更多的输入）。你可以做同样的事情：
if (key >= ' ')
printf ("key: %2d ('%c') ", key, key);
else
printf ("key: %2d ('') ", key);
(就是多打字:)
ASCII Table
Char Dec Oct Hex | Char Dec Oct Hex | Char Dec Oct Hex | Char Dec Oct Hex
-------------------------------------------------------------------------------------
(nul) 0 0000 0x00 | (sp) 32 0040 0x20 | @ 64 0100 0x40 | ` 96 0140 0x60
(soh) 1 0001 0x01 | ! 33 0041 0x21 | A 65 0101 0x41 | a 97 0141 0x61
(stx) 2 0002 0x02 | " 34 0042 0x22 | B 66 0102 0x42 | b 98 0142 0x62
(etx) 3 0003 0x03 | # 35 0043 0x23 | C 67 0103 0x43 | c 99 0143 0x63
(eot) 4 0004 0x04 | $ 36 0044 0x24 | D 68 0104 0x44 | d 100 0144 0x64
(enq) 5 0005 0x05 | % 37 0045 0x25 | E 69 0105 0x45 | e 101 0145 0x65
(ack) 6 0006 0x06 | & 38 0046 0x26 | F 70 0106 0x46 | f 102 0146 0x66
(bel) 7 0007 0x07 | ' 39 0047 0x27 | G 71 0107 0x47 | g 103 0147 0x67
(bs) 8 0010 0x08 | ( 40 0050 0x28 | H 72 0110 0x48 | h 104 0150 0x68
(ht) 9 0011 0x09 | ) 41 0051 0x29 | I 73 0111 0x49 | i 105 0151 0x69
(nl) 10 0012 0x0a | * 42 0052 0x2a | J 74 0112 0x4a | j 106 0152 0x6a
(vt) 11 0013 0x0b | + 43 0053 0x2b | K 75 0113 0x4b | k 107 0153 0x6b
(np) 12 0014 0x0c | , 44 0054 0x2c | L 76 0114 0x4c | l 108 0154 0x6c
(cr) 13 0015 0x0d | - 45 0055 0x2d | M 77 0115 0x4d | m 109 0155 0x6d
(so) 14 0016 0x0e | . 46 0056 0x2e | N 78 0116 0x4e | n 110 0156 0x6e
(si) 15 0017 0x0f | / 47 0057 0x2f | O 79 0117 0x4f | o 111 0157 0x6f
(dle) 16 0020 0x10 | 0 48 0060 0x30 | P 80 0120 0x50 | p 112 0160 0x70
(dc1) 17 0021 0x11 | 1 49 0061 0x31 | Q 81 0121 0x51 | q 113 0161 0x71
(dc2) 18 0022 0x12 | 2 50 0062 0x32 | R 82 0122 0x52 | r 114 0162 0x72
(dc3) 19 0023 0x13 | 3 51 0063 0x33 | S 83 0123 0x53 | s 115 0163 0x73
(dc4) 20 0024 0x14 | 4 52 0064 0x34 | T 84 0124 0x54 | t 116 0164 0x74
(nak) 21 0025 0x15 | 5 53 0065 0x35 | U 85 0125 0x55 | u 117 0165 0x75
(syn) 22 0026 0x16 | 6 54 0066 0x36 | V 86 0126 0x56 | v 118 0166 0x76
(etb) 23 0027 0x17 | 7 55 0067 0x37 | W 87 0127 0x57 | w 119 0167 0x77
(can) 24 0030 0x18 | 8 56 0070 0x38 | X 88 0130 0x58 | x 120 0170 0x78
(em) 25 0031 0x19 | 9 57 0071 0x39 | Y 89 0131 0x59 | y 121 0171 0x79
(sub) 26 0032 0x1a | : 58 0072 0x3a | Z 90 0132 0x5a | z 122 0172 0x7a
(esc) 27 0033 0x1b | ; 59 0073 0x3b | [ 91 0133 0x5b | { 123 0173 0x7b
(fs) 28 0034 0x1c | < 60 0074 0x3c | \ 92 0134 0x5c | | 124 0174 0x7c
(gs) 29 0035 0x1d | = 61 0075 0x3d | ] 93 0135 0x5d | } 125 0175 0x7d
(rs) 30 0036 0x1e | > 62 0076 0x3e | ^ 94 0136 0x5e | ~ 126 0176 0x7e
(us) 31 0037 0x1f | ? 63 0077 0x3f | _ 95 0137 0x5f | (del) 127 0177 0x7f
目标应该是使检测机制自动化。与其从详尽的列表中找到解密的短语，不如形成代码。
对 OP 的代码进行一些小的修改，下面调用各种 valid() 来评估解密有效性。
建议OP进一步调整valid()直到提供1"best"解密。然后找到解密的"formula"
为了好玩：试着找到这个间谍的 phone 号码和 Google 来确定名字。她的加密数据是"0>?%=;81"。相应地调整 valid()。
#include <stdio.h>
#if 1
int valid(const char *decrypt) {
size_t end = strspn(decrypt, " ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz");
return end == 8;
}
#else
int valid(const char *decrypt) {
size_t end = strspn(decrypt, " ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz");
if (end != 8) return 0;
for (int i=1; i<8; i++) {
if (isupper(decrypt[i-1]) && isupper(decrypt[i])) { //reject paired capital letters
return 0;
}
}
return 1;
}
#endif
int main(void) {
const char input[9] = "dEsxDI^I";
printf("Decryption for the Encrypted code \"dEsxDI^I\" :\n\n");
for (int key = 0; key <= 99; key++) {
char decrypt[9] = ""; // Variable Declarations and Initializations.
for (int i = 0; i < 8; i++) {
decrypt[i] = (char) (input[i] ^ key);
}
if (valid(decrypt)) {
printf("Key No %2d Decrypt:<%s>\n", key, decrypt);
}
}
return 0;
}
输出 - 第一个 valid()
Decryption for the Encrypted code "dEsxDI^I" :
Key No 1 Decrypt:<eDryEH_H>
Key No 10 Decrypt:<nOyrNCTC>
Key No 11 Decrypt:<oNxsOBUB>
Key No 16 Decrypt:<tUchTYNY>
Key No 17 Decrypt:<uTbiUXOX>
Key No 22 Decrypt:<rSenR_H_>
Key No 28 Decrypt:<xYodXUBU>
Key No 29 Decrypt:<yXneYTCT>
Key No 39 Decrypt:<CbT_cnyn>
Key No 42 Decrypt:<NoYRnctc>
Key No 43 Decrypt:<OnXSobub>
Key No 44 Decrypt:<Hi_There>
Key No 48 Decrypt:<TuCHtyny>
Key No 49 Decrypt:<UtBIuxox>
Key No 60 Decrypt:<XyODxubu>
Key No 61 Decrypt:<YxNEytct>
输出 - 第二 valid()
Decryption for the Encrypted code "dEsxDI^I" :
Key No 22 Decrypt:<rSenR_H_>
Key No 39 Decrypt:<CbT_cnyn>
Key No 44 Decrypt:<Hi_There>