Encoding 有没有什么好办法来；编码"；二进制数据作为似是而非的madeup字，然后再返回？

给你一个非常简单和糟糕的例子。数据被分成4位。16个可能的数字对应于前16个辅音。您添加一个随机元音以使其可发音。所以“08F734F7”可以变成“巴洛塔库佛戈塔卡”。你可以加入一些音节，加上标点符号和大写，它可以变成“Balo-ta-kufogo，Taka？”这看起来像是一种似是而非的语言

我只是想说清楚，我并不是在试图保护二进制数据

我想在压缩和加密我的（UTF-8）纯文本日记后使用它。生成的二进制数据看起来应该非常随机。我需要将这些数据转换成看似合理的语言，并能够将其还原回来。我要把“语言”印在纸上，然后定制一本书

所以我要寻找的是将随机数据转换成可读的可信单词的最佳方法。我所说的“好”是指最大的位字母比（同时使它看起来像一种真正的语言）。在我的例子中，每个字母正好是2位。或者4个字母代表一个字节。

请阅读此处

Base64编码需要三个字节， 每个由八位组成，以及 将它们表示为四个可打印的 ASCII标准中的字符。信息技术 这基本上分为两个步骤

第一步是转换三个 字节到四个六位数字。 ASCII标准中的每个字符 由七位组成。仅限Base64 使用6位（对应于2^6=64 字符），以确保编码数据 可打印且可读。没有一个 中可用的特殊字符的名称 使用ASCII码。64个字符 （因此命名为Base64）是10位数字， 26个小写字符，26个大写字符 字符以及“+”和“/”字符

例如，如果这三个字节是 155、162和233，对应的 （和可怕的）比特流是 100110111010001011101001，其中 turn对应于6位值 38、58、11和41

---

我个人会使用C++。对于一个可以实现您所描述的功能的程序，我会制作如下内容：

void JumbleData(const void *src, int srcLen, char *dest)
{
  for(int i = 0; i < srcLen; i++)
  {
    unsigned char data = *((unsigned char*)src+i);
    unsigned char lower  = data & 0x0F;
    unsigned char higher = (data & 0xF0) >> 4;

    dest = 'a' + lower; dest++;
    dest = 'a' + higher; dest++
  }
}

void JumbleData（常量void*src、int-srcLen、char*dest）
{
对于（int i=0；i>4；
dest='a'+更低；dest++；
目的地='a'+更高；目的地++
}
}

这应该将src数据分成4位部分，将其添加到“a”并将其放入目标。然后，您可以遍历并在之间添加额外的字母，但前提是您有一个字符串方式来反转该过程

为了让它不那么明显，我会一次使用超过4位，但也不会使用8位。下面是一个使用6位块的示例：

void AddData(char* &dest, unsigned char data);

void JumbleData(const void *src, int srcLen, char *dest)
{
  for(int i = 0; i < srcLen; i+=3)
  {
    unsigned char data0 = *((unsigned char*)src+i);
    unsigned char data1 = *((unsigned char*)src+i+1);
    unsigned char data2 = *((unsigned char*)src+i+2);

    unsigned char chunk0 = data0 & 0x3F;
    unsigned char chunk1 = (data0 >> 6) | ((data1 & 0x0F) << 2);
    unsigned char chunk2 = (data1 >> 4) | ((data2 & 0x03) << 4);
    unsigned char chunk3 = data2 >> 2;

    AddData(dest, chunk0);
    AddData(dest, chunk1);
    AddData(dest, chunk2);
    AddData(dest, chunk3);
  }
}

void AddData(char* &dest, unsigned char data)
{
  const char vowels[] = {'a', 'e', 'i', 'o'};
  char letter1 = 'a' + (data & 0x0F);
  char letter2 = vowels[((data & 0x0C) >> 2)];
  char letter3 = 'n' + ((data & 0x3C) >> 2);
  *dest = letter1;
  dest++;
  *dest = letter2;
  dest++;
  *dest = letter3;
  dest++;
  *dest = ' ';
  dest++;
}

void AddData（char*&dest，未签名的char数据）；
void JumbleData（常量void*src、int-srcLen、char*dest）
{
对于（int i=0；i>6）|（（data1&0x0F）>4）|（（data2&0x03）>2；
AddData（dest，chunk0）；
AddData（dest，chunk1）；
AddData（dest，chunk2）；
AddData（dest，chunk3）；
}
}
void AddData（char*&dest，未签名的char数据）
{
常量字符元音[]={'a'，'e'，'i'，'o'}；
字符letter1='a'+（数据&0x0F）；
char letter2=元音[（数据&0x0C）>>2]；
字符字母3='n'+（（数据&0x3C）>>2）；
*dest=字母1；
dest++；
*dest=字母2；
dest++；
*dest=字母3；
dest++；
*dest=''；
dest++；
}

---

这将使每个6位的数据块中的3个字母单词变得混乱。

您可以使用一组转换表执行简单的替换算法，该转换表根据原始数字中数字的幂而变化。对转换表中的值进行加权，以使元音和某些辅音更为常见。选择一些足够大的基数，以便各地的ave变化。例如（基于十六进制的数据）：

（这也可以通过为每一列选择简单的公式来实现…）

所以

将此扩展到足够多的列，以便更好地控制所有字符的分布。如果源数据没有干净的随机分布，您可能也希望混淆列与列之间的顺序。请注意，有些字符在每列中存在，有些仅存在一次。此外，还可以调整元音到辅音的频率d通过改变每列中的平均比率

获取固定大小的大块数据，并通过转换器运行它们，然后应用间距/标点符号/大小写算法

（不能保证你不会得到一个全辅音或极低元音数的单词，但你可以让大写算法使它看起来像首字母缩略词/首字母缩略词）

有趣的问题

到目前为止，我最好的解决方案是将12位编码为2到4个字符，每个字母编码3到6位。（星期五不是对单词长度不均匀分布进行必要数学计算的好日子，所以我还没有计算出每个字母的平均位数）

我们的想法是使用以一个或两个辅音开头，以一个或两个元音结尾的“音素”。共有21个辅音，我觉得每个辅音后面都可以跟一个h、l、r、w或y，而且看起来仍然合理。因此，你的音素从126个辅音部分中的一个开始-b、bh、bl、br、bw、by、c、ch、cl、cr、…、z、zh、zl、zr、zw、zy（无可否认，像yy和zl这样的人看起来有点奇怪，但毕竟它是一门外语：）

126非常接近128，我们可以为最后两个值加上t'和b'（例如），这给了我们一个128个值的字典，以存储7位。你甚至可以加上用d'替换yy，用p'替换zl，或者其他什么

同样，元音porti

value | place  
      | 0 1 2 ...
------|------ - - -
  0   | a a a ...
  1   | e e e
  2   | i i i
  3   | o o q
  4   | u u w
  5   | y q r
  6   | q w f
  7   | w r g
  8   | r f h
  9   | t g j
  A   | p h k
  B   | s j c
  C   | d k v
  D   | f l b
  E   | g z n
  F   | h x m ...

B4B => "suc"
3AA => "ohk"
F62 => "iwm"
...

cur=grammar.root (cur is a list of tokens)
n=my input as one big integer 
while(n > 0 || cur != grammar root){
    if (cur.first.isTerminalSymbol) { 
        output cur.first
        cur.pop_first
        if(cur.isEmpty){
            cur = grammar root
        }
    }else{
        p = grammar[cur.first].number of productions
        t = n mod p // t = low order digit base p
        n = n div p // Shift left in base p
        cur.pop_first
        cur.push_first( grammar[cur.first].productionNumber[t] )
    }
}

25079713 % 2 = 1  n=125396856, S-> __capital Noun T-Verb Noun Punct
125396856 % 2 = 0 n=62698428,  Noun->NS _space-> NSS Vowel _space
62698428 % 2 = 0  n=31349214,  NSS->j
31349214 % 6 = 0  n=5224869,   Vowel->a
5224869 % 2 = 1   n=2612434,   T-Verb->TVS T-Verb->TVSS Vowel T-Verb
2612434 % 2 = 0   n=1306217,   TVSS->p
1306217 % 6 = 5   n=217702,    Vowel->y
217702 % 2 = 0    n=108851,    T-Verb->TVSS Vowel _space
108851 % 2 = 1    n=54425,     TVSS->s
54425 % 6 = 5     n=9070,      Vowel->y
9070 % 2 = 0      n=4535,      Noun->NSS Vowel _space
4535 % 2 = 1      n=2267       NSS->v
2267 % 6 = 5      n=377        Vowel->y
377 % 3 = 2       n=125        Punct->?
125 % 2 = 1       n=62         S->__capital Noun T-Verb Noun Punct
62 % 2 = 0        n=31         Noun->NSS Vowel _space
31 % 2 = 1        n=15         NSS->v
15 % 6 = 3        n=2          Vowel->o
2 % 2 = 0         n=1          T-Verb->TVSS Vowel _space
1 % 2 = 1         n=0          TVSS->p
                  n=0          Vowel _space Noun Punct -> "a ja." 

  ...
  (key:'_t'; next:'aehioruwy'),
  (key:'_u'; next:'lmnprst'),
  (key:'_w'; next:'aehiory'),
  (key:'ab'; next:'abeilorsuwy'),
  (key:'ac'; next:'_acehikloqrtuy'),
  ...

Furepas_Wann_Hunkare_Rylacid_Makinuag_Dreem

Togo_Ragam_Omb_Bonsbe_Gonn_Eclecki_Op

Lakar_Rupplex_Waylagit_Munghim_Paddato_Molu