0

我遇到了这个练习，它要求您解密下图中加密代码中的隐藏消息。

链接到图片

本练习与位运算符有关，因此我假设我们需要使用“XOR”运算符来解密具有 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”。只是想知道这是正确的信息吗？因为这是我解密的所有消息中最合乎逻辑的消息。

这个练习没有提供解决方案，所以我很好奇。那么，你们的输出是什么？

4

3 回答 3

0

我解密的消息是“Hi_There”，加密密钥为“44”。只是想知道这是正确的信息吗？

关于 8 字符密码的解决方案是否必须是 8 字符解决方案没有明确的指示，但这是一般情况。如果没有明确的说明（“您的解决方案可能包含或不包含密码中的所有字符。 ”），我会寻找包含 8 个字符的解决方案。

尽管您没有提供代码的细节，但对所有可能的键进行简单的暴力循环与其他任何方法一样好。由于没有为您提供解决方案，因此您无法在此过程中进行任何比较。您能做的最好的事情是遍历所有密钥，将其应用于密码中的每个字符并输出结果——然后使用您的“好眼力”来挑选解决方案。（如果您知道解决方案将全部是大写/小写字符 - 您可以在输出每个结果以供手动检查之前强制执行该检查）。

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;
}

示例使用/输出

$ ./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>

使用XOR应用到密钥并使用手动眼球扫描解决方案，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语句的简写，其中表达式的结果基于给定的测试条件。本质上，三元运算符是：

condition ? if_true_value : if_false_value

在我的printf声明中，我只是这样做：

printf ("key: %2d ('%c')   ", key, key >= ' ' ? key : 0);

显然，整数值key与%2d转换说明符一起使用，以确保所有key值都打印两个字符宽（这是2 字段宽度说明符的目的。现在让我们看看我想通过什么字符打印%c。

key >= ' ' ? key : 0    // huh?

这很简单。第一个可打印的 ASCII 值是0x20（十六进制）或32十进制，对应于' '（空格）字符。请参阅下面的 ASCII 表。那么我的测试条件是什么？如果(key >= ' ')大于等于空格。如果是，只需打印由 . 表示的字符key。如果不是，则打印空字符（它是十进制0或等效字符'\0'——只需要更多的输入）。你可以做同样的事情：

if (key >= ' ')
    printf ("key: %2d ('%c')   ", key, key);
else
    printf ("key: %2d ('')   ", key);

（只是更多的打字:)

ASCII 表

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
于 2017-09-22T12:48:07.337 回答
0

目标应该是自动化检测机制。与其从详尽的列表中找到解密的短语，不如编写代码。

通过对 OP 的代码进行一些小的修改，下面调用各种valid()来评估解密的有效性。

建议 OP 进一步调整valid()，直到它提供 1 个“最佳”解密。然后找到解密的“公式”。

为了好玩：试着找到这个间谍的电话号码和谷歌来确定名字。她的加密数据是"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>
于 2017-09-22T16:17:12.573 回答
0

我对您解密的消息进行了 XOR、~XOR、AND、NAND、OR、NOR、左移、右移操作。

正如我们任何人所认为的那样，答案自然是44。

我没有从该字符串中获得任何其他可读消息。

虽然如果您考虑所有可能性：

异或：

  1. 键 12：hItHERE
  2. 键 44：Hi_There
  3. 键 112：49.9____

用空格替换下划线（不是不可打印的字符，只是空格）

或者：

  1. 键 14：no~no~o
  2. 键 46：no~no~o

是的，它们都是相同的，实际上 OR 会产生很多带有重复字符的字符串，例如 '{{{{{{{{'

~异或：

  1. 键 243：hItHERE
  2. 键 211：Hi_There

现在可读消息的定义取决于每个人。

hItHERE可能是空袭的一些标志。

no~no~o可能是寻求帮助或拒绝某事。

49.9可能是生物武器实验室中某种秘密成分的数量。

0~99 是一个相当有限的范围。

于 2017-09-22T11:08:42.780 回答