如何使用密码和Java将12位十进制数字加密/解密为其他数字？

Question

我已经读过《 使用Java加密整数》和《 使用通行短语用DES加密》 。

我需要的是一个简单的Encrypter，它将具有以下约束的12位数字转换为12位数字：

1. 加密必须依赖于密码（在应用程序的整个生命周期中保持不变），而不能依赖其他任何密码。
2. 映射必须为1-1（无哈希且多个输入具有相同的输出，反之亦然）。
3. 映射不得在不同的VM之间或启动VM时更改（例如，当您重新启动Java时，该实用程序应为您提供相同的映射，这意味着它必须完全取决于所提供的密码）。
4. 以0开头的数字不是有效的12位数字（输入的数字也不会以0开头）。
5. 密钥/密码永远不可猜测。 例如，运行具有多个输入的实用程序并分析输出，不应让人们猜测密钥/密码/哈希或其他内容。
6. 所有输入将完全是12位数字，并且少于12位素数（这意味着我们可以使用模算术）。

翻阅文学作品后，我有了这段代码

public void mytestSimple(long code, String password) throws Exception {
    SecretKey key = new SecretKeySpec(password.getBytes(), "DES");
    Cipher ecipher = Cipher.getInstance("DES");
    ecipher.init(Cipher.ENCRYPT_MODE, key);
    System.out.println(ecipher.getOutputSize(8));

    byte[] encrypted = ecipher.doFinal(numberToBytes(code));
    System.out.println(encrypted + "--" + encrypted.length);

    Cipher dcipher = Cipher.getInstance("DES");
    dcipher.init(Cipher.DECRYPT_MODE, key);
    byte[] decrypted = dcipher.doFinal(encrypted);
    System.out.println(bytesToNumber(decrypted) + "--" + decrypted.length);
}

public void testSimple() throws Exception {
    mytestSimple(981762654986L, "password");
}

我遇到了关于

1. 如何将16个字节转换为12位数字。
2. 保持1-1映射。
3. 在多个VM调用之间保持加密/解密相同。

****我在下面添加的答案****

我添加了一个答案，即从标准Ja​​va RSA密钥对生成逻辑中抽出的40位RSA。 我仍然需要处理极端情况。 我将接受答案并投票赞成“ Tadmas”，我认为这会引导我找到答案。 有人可以告诉我我的算法是否很弱/容易受到攻击吗？

Answer 1

您将无法在不丢失信息的情况下将16字节转换为12位数字。 256 ^ 16> 10 ^ 12。 （并不是说您甚至还有10 ^ 12个选项，因为您只有范围[100000000000，999999999999]。

我怀疑您是否可以使用任何传统的加密库，因为您的要求有些奇怪。

Answer 2

如果严格的1：1映射比防止密码分析更重要，则可以将密码转换为12位数字（通过哈希或其他方式），然后只需将其添加到原始数字mod 10 ^ 12中即可。 如果绝对必须从输出中删除前导零，则可以减去10 ^ 11，进行数学模（10 ^ 12-10 ^ 11），然后再次添加10 ^ 11。 当然，这是非常不安全的，但是非常简单。 :)

如果输入范围以小于（10 ^ 12-10 ^ 11）的质数为界，则您可以使用message ^ password mod prime形成一个环，该环将满足您的要求，并且更难破解。 （这类似于RSA的工作方式。）我认为，如果不需要解密它，则可以使用。

我同意Jon Skeet的观点：大多数加密库都无法处理严格的1：1映射，且输出范围不大于输入域。

Answer 3

可以在Feistel密码上建立一种潜在的解决方案。 这种构造允许基于伪随机函数构建伪随机排列。 例如，可以通过将结果截断为6位数字，从适当的分组密码中构造伪随机函数。

在下面的论文M.Luby和C.Rackoff，“如何从伪随机函数构造伪随机排列”中对此结构进行了分析，《 SIAM计算杂志》，第17卷，第2期，第373--386页，1988年。

---

一个具体的建议是Feistel有限集加密模式 ，该模式已提交给NIST，有可能包含在即将发布的标准中。 该提议还解决了加密范围不是2的幂的问题。

Answer 4

我建议一个非常简单的算法。

1. 将密码输入哈希函数。
2. 用哈希或从哈希中派生的东西初始化随机数生成器。
3. 生成一个12位数字的随机数。
4. 将此随机数加到输入的位数以10为模的方式进行加密。

要解密，减去10模的随机数。 这实际上是 One Time Pad的一种形式。 由于对这个答案的评论，我意识到引用One Time Pad是一个错误的选择。 更好的参考是多字母密码 -“一个时间板”使用多字母替换，其主要特征是不两次使用任何密钥位。

Input           1234 1234 1234
   Random number   6710 3987 2154
   Output          7944 4111 3388

仍然存在一个问题-算法可能会创建前导零。 为了解决这个问题，可以使用XOR代替加法和减法。 只需使用XOR转换数字即可。 如果第一位变为零，请不要加密第一位。 当再次使用XOR解密时，第一个数字将变为零，并且您知道第一个数字未加密。

更新

简单的XOR并不是解决方案，因为它将产生大量数据-例如2 XOR 9 = 11 。 要重新考虑这一点...

更新

XOR的好特性是XOR(a, b) = XOR(b, a)和XOR(XOR(a, b), b) = a 。 这使得加密和解密相同，并允许检测未加密的前导数字。 但是进一步要求我们的函数仅返回0到9范围内的值，而XOR则不会。
但是也许我们可以构建具有所有必需属性的自定义函数。 因此，我们创建了一个包含10列10行的FUNC数组，并将其用作函数的查找表。 除了什么价值？ 我实际上不知道-我什至不确定是否有可能。 但是，如果我们从0到9范围内选择三个数字，则必须输入以下六个条目。 （这是一个对称矩阵。）

FUNC[x,y] = z   FUNC[x,z] = y   FUNC[y,z] = x
FUNC[y,x] = z   FUNC[z,x] = y   FUNC[z,y] = x

因此，也许可以通过重复选择随机数并在没有冲突的情况下填写六个条目来创建这样的功能。 也许不是。 如果有人找到解决办法，我想看看这张桌子。

Answer 5

如果数字用于用户标识，这就是我要做的：

（1）根据密码生成AES密钥。 如果您信任管理员使用非常强壮的密码，只需要调用getBytes（）就可以了。 理想情况下，使用标准的“基于密码的加密”技术对字节进行哈希处理（例如，数千次），每次都添加最初生成的随机“盐”字节，以避免字典攻击。

（2）用该AES密钥加密有问题的号码。

（3）从生成的加密块中截取12位的位数，将其转换为十进制，然后将该数字呈现给用户。 （为此，您可以将BigInteger包裹在字节周围，在其上调用toString（），然后提取例如位置4和16之间的字节。）从实验上看，您似乎不应该从最右端。

[ 更新 ：我认为这可能是因为BigInteger从字面上按从左到右的顺序分配了其数字-但我尚未检查-因此，最右边的字节中可能有“备用”位，因此可能的数字更少如果您包括最后一个字节。]

现在，我听到你在哭，这显然不是1-1映射。 但是除非您将拥有成千上万的用户，否则它确实足够好。 使用12位数字，您平均希望在发生冲突之前先加密大约300,000个数字。 因此，尽管您严格地没有1-1映射，但实际上，它几乎是可恶的。

（在任何情况下，如果您的应用程序确实有成千上万的用户，并且安全性至关重要，那么您可能需要对这种事情进行一些认真的咨询...）

只是为了让自己相信可以假装是1-1映射确实可以，您可以运行一个模拟，反复尝试使用随机密钥分配200,000个用户ID，并打印出每次运行有多少次碰撞：

 next_pass :
        for (int pass = 0; pass < 100; pass++) {
          byte[] key = new byte[16];
          (new SecureRandom()).nextBytes(key);
          Cipher ciph = Cipher.getInstance("AES");
          SecretKeySpec ks = new SecretKeySpec(key, "AES");
          ByteBuffer bb = ByteBuffer.allocate(16);
          Set<String> already = new HashSet<String>(100000);
          int colls = 0;
          for (int i = 0; i < 200000; i++) {
            bb.putLong(0, i);
            ciph.init(Cipher.ENCRYPT_MODE, ks);
            byte[] encr = ciph.doFinal(bb.array());
            encr[0] &= 0x7f; // make all numbers positive
            BigInteger bigint = new BigInteger(encr);
            String userNo = bigint.toString();
            userNo = userNo.substring(4, 16);
            if (!already.add(userNo)) {
              System.out.println("Coll after " + i);
              continue next_pass;
            }
          }
          System.out.println("No collision.");
        }

Answer 6

我将使用流 密码 。 输入N个字节，输出N个字节。

Answer 7

该线程已有4年的历史了，但是对于那些在Google中找到该线程的人来说：请参阅格式保存密码： http ： //en.wikipedia.org/wiki/Format-preserving_encryption

Answer 8

我认为Tadmas下面给出的答案非常有帮助，我希望你们在下面破解/欺负我的实现。 正如Tadmas指出的，我所有的数字都是40位（12位数字是10 ^ 12，大约是2 ^ 40）。

我复制了sun.security.rsa.RSAKeyPairGenerator（链接），并为40位RSA算法创建了自己的生成器。 标准之一需要512-1024位，因此我删除了它周围的输入检查。 一旦我创建了合适的n，e，d值（按照alog，e似乎是65537）。 以下代码很好用，

public void testSimple() throws NoSuchAlgorithmException {
    MyKeyPairGenerator x = new MyKeyPairGenerator();
    x.initialize(40, new SecureRandom("password".getBytes()));

    MyPublicPrivateKey keypair = x.generateKeyPair();
    System.out.println(keypair);

    BigInteger message = new BigInteger("167890871234");
    BigInteger encoded = message.modPow(keypair.e, keypair.n);
    System.out.println(encoded); //gives some encoded value
    BigInteger decoded = encoded.modPow(keypair.d, keypair.n);
    System.out.println(decoded); //gives back original value
}

缺点

1. 编码后的数字不一定总是12位（有时可能以0开头，这意味着只有11位）。 我想总是在前面填充0零，并在开头添加一些CHECKSUM数字，这可以缓解此问题。 所以总是13位数...
2. 40位RSA比512位弱（不仅是512/40倍，而且是指数倍）。 您能为我指出40位RSA与512位RSA相比有多安全的链接吗（我可以在Wiki中看到某些内容，但无法具体确认受到攻击的可能性）？ 关于概率/破解N的函数所需的RSA尝试次数/概率的任何链接（wiki？）（其中n是所使用的位数）将非常棒！

Answer 9

出于数学原因，大多数密码将产生“更多”字节（即，它们将填充输入）。 因此，您将不得不接受该代码从您的12位数字中生成16字节。

字符串解码后，您将获得12位数字，但在传输过程中需要16个字节。

Answer 10

如果我正确理解了您的问题，则解密后的16个字节有问题。 诀窍是使用：Cipher.getInstance（“ DES / ECB / PKCS5Padding”）;

（以防万一代码有帮助）：

public void mytestSimple(long code, String password) throws Exception 
       { SecretKey key       = new SecretKeySpec (password.getBytes(),"DES");
         Cipher    ecipher   = Cipher.getInstance("DES/ECB/PKCS5Padding");
         byte[]    plaintext = new byte[8];

         for (int i=0; i<8; i++)
             { plaintext[7-i] = (byte) (code & 0x00FF);
                >>>= 8;
             }

         ecipher.init      (Cipher.ENCRYPT_MODE, key);
         System.out.println(ecipher.getOutputSize(8));

         byte[] encrypted = ecipher.doFinal(plaintext);
         System.out.println("--" + encrypted.length);

         Cipher dcipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
         dcipher.init(Cipher.DECRYPT_MODE, key);

         byte[] crypttext = dcipher.doFinal(encrypted);
         long   decoded    = 0;

         for (int i=0; i<8; i++)
             { decoded <<= 8;
               decoded  += crypttext[i] & 0x00FF;
             }

         System.out.println(decode + "--" + crypttext.length);
       }

Answer 11

重新思考问题后，我想到了以下内容。 基本上，您需要使用对称密码来获得一对一映射。 并注意到10^12几乎是2^40 （ 2^39.863 ），将您的12位数字转换为40位整数并将该数字输入具有40位块长度的块密码中似乎很自然。 一个不错的选择是 Blowfish以8位为步长支持32到448位的块长度-因此支持40位。

---

更新

正如Accipitridae指出的那样，河豚的密钥大小可变，但块大小固定，因此这是没有选择的。 在网络上进行的更多搜索似乎表明，很少或根本没有密码大小为40位或更少的密码，这使该想法无效。 留下答案的其余部分-也许可以找到合适的密码。

---

剩下的问题是 河豚 可能返回的数字最多为1,099,511,627,775含13位数字），并且返回的数字可能包含前导零，但是我认为可以在第二步中解决。 我的第一个想法是对数字的字符串表示形式应用诸如Burrows-Wheeler变换之类的方法，以便使数字的第一个数字至少获得一个零，从而消除第13位数字，然后修改所有剩余的数字（例如0 <-> 9、1 <-> 8、2 <-> 7，...）将其他前导零转换为其他数字。
几分钟后，我重新判断这将不起作用-输入的大小为2^40而输出的大小仅为2^39.863 。 一种解决方案是使用39位的分组密码并将输入限制为最大549,755,813,887 。 我不知道是否存在可以处理39位块长度的密码 ，但是有关Elastic Block Ciphers的这篇论文介绍了如何构造一个可以处理从n到给定2n每个块大小的块密码。可以处理块大小n密码。 结果，有可能从32位的Blowfish构建39位的分组密码。

Answer 12

如果您准备接受一个较弱的解决方案 ...

将12位数字视为两个6位数字。 然后，使用密码的哈希值作为随机数生成器的种子，该随机数生成器将对999,990个连续值的表进行混洗。 然后使用两个6位数字在表中查找条目。 这两个结果的串联是基于密码的1：1映射的12位“加密”输入。

让我们以4位数字代替12位数字为例...

Input: 4852
Password: passw0rd1 => hashcode = 37592

现在拿这个数组。

a = [10, 11, 12, 13, .. 98, 99]

并以37592作为随机种子对其进行洗牌...

b = [45, 15, 56, 49, .. 33, 88]

现在拆分输入：48、52，并在洗过的数组中查找那些索引，说...

b[48] => 23
b[52] => 96

因此我们的4852加密版本为2396

这确实不是一个强力的解决方案，但您的问题中的约束不会导致一个强力的解决方案。 您可能需要放松一些约束。