Language agnostic Rot13用于数字编辑：现在在_Language Agnostic_Math_Encryption_Function

Language agnostic Rot13用于数字编辑：现在在

language-agnostic math encryption function

Language agnostic Rot13用于数字编辑：现在在,language-agnostic,math,encryption,function,Language Agnostic,Math,Encryption,Function,其目的是模糊文本，例如防止破坏者。它并不意味着加密安全，而是简单地确保只有那些确信自己想要阅读它的人才会阅读它我想对数字做一些类似的事情，对于涉及密封投标的应用程序。大致上，我想把我的号码发给某人，并相信他们会选择自己的号码，而不受我的影响，但他们应该能够在准备好后透露我的号码（纯粹是客户端的）。他们不需要我或任何第三方的进一步输入（补充：注意收件人被信任不会作弊的假设。）它不像rot13那么简单，因为某些数字，比如1和2，会反复出现，你可能会记得，比如说，34.2实际上是1 以下是我特别

其目的是模糊文本，例如防止破坏者。它并不意味着加密安全，而是简单地确保只有那些确信自己想要阅读它的人才会阅读它

我想对数字做一些类似的事情，对于涉及密封投标的应用程序。大致上，我想把我的号码发给某人，并相信他们会选择自己的号码，而不受我的影响，但他们应该能够在准备好后透露我的号码（纯粹是客户端的）。他们不需要我或任何第三方的进一步输入

（补充：注意收件人被信任不会作弊的假设。）

它不像rot13那么简单，因为某些数字，比如1和2，会反复出现，你可能会记得，比如说，34.2实际上是1

以下是我特别想要的：

将实数映射到实数（或字符串）的函数seal（）。它不应该是确定性的——seal（7）不应该每次都映射到同一个对象。但是相应的函数uncel（）应该是确定性的——uncel（seal（x））应该等于所有x的x。我不希望seal或uncel调用任何Web服务，甚至不希望获取系统时间（因为我不希望假设时钟是同步的）。（补充：假设所有出价都低于某个大家都知道的最大值，比如一百万，这是可以接受的。）

健全性检查：

> seal(7)
482.2382   # some random-seeming number or string.
> seal(7)
71.9217    # a completely different random-seeming number or string.
> unseal(seal(7))
7          # we always recover the original number by unsealing.

> seal(7)
fhrlls hqufw huqfha frira afsb ht ahuqw ajaijzji
> seal(7)
qbua adfshua hqgya ubiwi ahp wqwia qhu frira wge
> unseal(seal(7))
sueyyf udhsj seven ahkua snsfo ug nuhdj nwnvwmwv

> seal(7)
716017
> seal(7)
518497
> unseal(seal(7))
7

如果出价是相当大的数字，那么用一个预先确定的随机数进行位异或怎么样？再次XORing将检索原始值。

只要客户机和服务器都知道，您可以随时更改号码。

您可以设置不同的基数（如16、17、18等），并跟踪您已“密封”出价的基数

当然，这假设了大量数据（至少大于您使用的基数）。如果它们是十进制的，则可以删除该点（例如，27.04变为2704，然后将其转换为基数29…）

您可能希望使用基数17到36（只是因为有些人可能会识别十六进制并能够在头脑中翻译它…）

这样，您就可以拥有像G4、Z3或KW这样的数字（取决于您要密封的数字）.

如果您希望这样做，您是否知道您需要比原始数字更大的“密封”数字集

因此，你需要以某种方式限制你的实数，或者存储你没有显示的额外信息。

这里有一种便宜的方法可以利用rot13：

假设我们有一个函数gibberish（），它生成类似“fdjk alqef lwwqisvz”的内容，还有一个函数词（x），它将数字x转换为单词，例如，单词（42）返回“四十二”（无连字符）

然后定义

seal(x) = rot13(gibberish() + words(x) + gibberish())

及

当然，unchal的输出不是一个实际的数字，并且只对人类有用，但这可能没问题。你可以用单词到数字的函数使它变得更复杂一些，它也可以扔掉所有乱七八糟的单词（定义为任何不属于数字单词的单词——我想只有不到一百个）

健全性检查：

> seal(7)
482.2382   # some random-seeming number or string.
> seal(7)
71.9217    # a completely different random-seeming number or string.
> unseal(seal(7))
7          # we always recover the original number by unsealing.

> seal(7)
fhrlls hqufw huqfha frira afsb ht ahuqw ajaijzji
> seal(7)
qbua adfshua hqgya ubiwi ahp wqwia qhu frira wge
> unseal(seal(7))
sueyyf udhsj seven ahkua snsfo ug nuhdj nwnvwmwv

> seal(7)
716017
> seal(7)
518497
> unseal(seal(7))
7

我知道这很傻，但如果你有rot13可用，这是一种“手工”的方式。

你想做的（a）不可能只在客户端完成。最好是使用共享密钥进行加密

如果客户不需要你的合作来透露号码，他们可以修改程序来透露号码。您可能只是发送了它，而没有显示它

要正确地执行此操作，您可以发送一个安全的出价哈希+一个随机盐。这使你对你的出价负责。另一个客户可以用同样的方式承诺他们的出价。然后你们每人分享你们的出价和盐

[编辑]由于您信任其他客户端：

Sender:
Let M be your message
K = random 4-byte key
C1 = M xor hash(K) //hash optional: hides patterns in M xor K
//(you can repeat or truncate hash(K) as necessary to cover the message)
//(could also xor with output of a PRNG instead)
C2 = K append M //they need to know K to reveal the message
send C2 //(convert bytes to hex representation if needed)

Receiver:
receive C2
K = C2[:4]
C1 = C2[4:]
M = C1 xor hash(K)

由于您似乎假设其他人在自己出价之前不想知道您的出价，并且可以相信他们不会作弊，因此您可以尝试一种可变轮换方案：

from random import randint

def seal(input):
    r = randint(0, 50)
    obfuscate = [str(r)] + [ str(ord(c) + r) for c in '%s' % input ]
    return ':'.join(obfuscate)

def unseal(input):
    tmp = input.split(':')
    r = int(tmp.pop(0))
    deobfuscate = [ chr(int(c) - r) for c in tmp ]
    return ''.join(deobfuscate)

# I suppose you would put your bid in here, for 100 dollars
tmp = seal('$100.00') # --> '1:37:50:49:49:47:49:49' (output varies)
print unseal(tmp) # --> '$100.00'

在某种程度上（我想我们可能已经通过了），这变得很愚蠢，因为这很简单，你应该只使用简单的加密，邮件接收者总是知道密钥——可能是此人的用户名。

一种简单的方法是写一封邮件，如：

“我的出价是：$14.23:Aduigfurjwjnfdjfugfojdjkdskdfdhfddfuiodrnfnghfyis”

所有这些垃圾都是随机产生的，每次都不一样

将消息的SHA256哈希值发送给其他人。让他们给你发一份他们的出价。然后，一旦你们都有了散列，发送完整的消息，并确认他们的出价对应于他们给你的散列

这提供了比你需要的更有力的保证——实际上，在你向他们发送完整信息之前，他们不可能计算出你的出价。但是，没有您描述的uncel（）函数

这个简单的方案有着完全零知识方案所不具备的各种弱点。例如，如果他们通过给你发送一个随机数而不是散列来伪造你的出价，那么他们可以在不透露自己出价的情况下计算出你的出价。但你没有要求防弹。这可以防止意外和（我认为）不可检测的欺骗，并且只使用一个常用的命令行实用程序，加上一个随机数生成器（骰子就可以了）

如您所说，如果您希望他们能够在没有您进一步输入的情况下恢复您的出价，并且您只愿意信任他们在发布他们的出价后才能恢复出价，那么只需使用任何旧的对称密码（

gpg--symmetric

）和密钥“rot13”进行加密即可。这将防止意外欺骗，但允许不可检测的欺骗。

如果您依赖于用户的诚实，并且只处理整数出价，那么您只需要一个简单的随机数异或操作，例如C#：

使用：

将解码过程转换为客户端构造应该足够简单。

是否有一个准则

               |
       A       +
               |
               C
               |
---+---+---+---|---+---B---+---+---+---
               |
               +
               |
               +

value = 2000
key = random(0..255); // our key is only 2 bytes

// 'sealing it'
value = value XOR 2000;

// add key
sealed = (value << 16) | key

key = sealed & 0xFF
unsealed = key XOR (sealed >> 16)

M = 9999  # Upper bound on bid.
seal(x) = M * randInt(9,99) + x
unseal(x) = x % M

> seal(7)
716017
> seal(7)
518497
> unseal(seal(7))
7

M = 9999  # Numbers between -M/2 and M/2 can be sealed.
seal(x) = M * randInt(9,99) + x
unseal(x) = 
  m = x % M; 
  if m > M/2 return m - M else return m