串行键：怎么办？

Question

我一直在这里阅读一些帖子和网络上的文章，但我无法为我的应用程序描绘一个基于串行键的系统。

http://www.brandonstaggs.com/2007/07/26/implementing-a-partial-serial-number-verification-system-in-delphi/

我看这一个，但我不能把代码放到Java和我不是很熟悉的条款会。

你能给我什么可能的见解吗？理想情况下，我的应用程序将用于销售，但我不认为它会很受欢迎，如果我有让用户欣赏产品并购买它的用户，我不介意太多，但我想避免它很容易破解。请尽量具体，我对Java有点新鲜。

在此先感谢。

Answer 1

这并不难，如果你的需求有些灵活 - 也许下面的方案会适合你。

您可以生成K = [SN，H（[X，SN，Y]）]，它是递增序列号与散列的并置，其中散列是串联的安全散列函数唯一常数X和Y之间的序列号是秘密的"salt" you use to prevent the use of rainbow tables。

使用一个众所周知的安全散列算法（例如SHA-1或SHA-2，MD5大概也就足够了，因为对MD5已知的弱点是冲突攻击，并不preimage attacks），你应该准备就绪，至少就序列关键部分而言（您可能希望防止两个人使用相同的关键字）。

你可以做的其他事情有用的是使用K = [SN，T，H（[X，SN，T，Y]）] - 同时使用序列号和时间戳。这可以用来为串行密钥只允许一个窄的使用窗口：它在时间戳的N秒内有效，所以它会阻止在该窗口之外重用密钥。然后将K编码/解码为可用于容易地允许用户输入密钥（例如base64）的表示。

最好有一个简单而透明的整体算法 - 如果有人反向设计你的方案，混淆不会帮助你。

Answer 2

确保应用程序的安全并不是一项简单的任务。许多公司正在投入大量资金来寻找新的安全算法，这些算法都可以快速破解。

保护Java应用程序有点困难。嵌入在您的应用程序中的任何串行验证算法都可以反编译，因此串行密钥生成器将非常易于构建。

一个好的起点是你给的文章。它会告诉您如何构建密钥验证系统，以及如何为您的（合法）用户生成密钥。

实施这样的算法后，我建议你稍微保护一下源代码，这样反编译变得更加“棘手”了。使用代码混淆技术来隐藏您的验证算法实现。这也会让试图通过修改字节码来破解应用程序的任务变得更加困难。

一个好的技术可能是将您的密钥验证算法导出到远程服务器上。客户端将密钥发送给服务器，服务器使用“验证代码”回复，告诉您的应用程序您的密钥是有效的。但这并不妨碍用户修改您的应用程序以删除任何密钥验证程序。对于没有24小时互联网连接的合法用户来说，这可能会非常烦人。我正在考虑Steam，它在互联网上每次发布时验证关键效度，并且会让很多用户感到困扰。

要找到一个好的保护技术，环顾四周，并尝试确定别人如何做，哪些技术正在工作，哪些不是。他们是很多例子（特别是电子游戏产业）。但请记住，即使是最好的公司也无法正确保护他们的应用程序。没有技术是牢不可破的。

Answer 3

我对那篇文章很感兴趣，所以我用Java实现了代码。可能是使用

import java.util.Locale; 
import java.util.Set; 
import java.util.TreeSet; 

public class KeyValidator { 
    private static final byte[][] params = new byte[][] { { 24, 4, 127 }, { 10, 0, 56 }, { 1, 2, 91 }, { 7, 1, 100 } }; 
    private static final Set<String> blacklist = new TreeSet<String>(); 

    static { 
     blacklist.add("11111111"); 
    } 

    private static byte PKV_GetKeyByte(final int seed, final byte a, final byte b, final byte c) { 
     final int a1 = a % 25; 
     final int b1 = b % 3; 
     if (a1 % 2 == 0) { 
      return (byte) (((seed >> a1) & 0x000000FF)^((seed >> b1) | c)); 
     } else { 
      return (byte) (((seed >> a1) & 0x000000FF)^((seed >> b1) & c)); 
     } 
    } 

    private static String PKV_GetChecksum(final String s) { 
     int left = 0x0056; 
     int right = 0x00AF; 
     for (byte b : s.getBytes()) { 
      right += b; 
      if (right > 0x00FF) { 
       right -= 0x00FF; 
      } 
      left += right; 
      if (left > 0x00FF) { 
       left -= 0x00FF; 
      } 
     } 
     int sum = (left << 8) + right; 
     return intToHex(sum, 4); 
    } 

    public static String PKV_MakeKey(final int seed) { 
     // Fill KeyBytes with values derived from Seed. 
     // The parameters used here must be exactly the same 
     // as the ones used in the PKV_CheckKey function. 
     // A real key system should use more than four bytes. 
     final byte[] keyBytes = new byte[4]; 
     keyBytes[0] = PKV_GetKeyByte(seed, params[0][0], params[0][1], params[0][2]); 
     keyBytes[1] = PKV_GetKeyByte(seed, params[1][0], params[1][1], params[1][2]); 
     keyBytes[2] = PKV_GetKeyByte(seed, params[2][0], params[2][1], params[2][2]); 
     keyBytes[3] = PKV_GetKeyByte(seed, params[3][0], params[3][1], params[3][2]); 

     // the key string begins with a hexadecimal string of the seed 
     final StringBuilder result = new StringBuilder(intToHex(seed, 8)); 

     // then is followed by hexadecimal strings of each byte in the key 
     for (byte b : keyBytes) { 
      result.append(intToHex(b, 2)); 
     } 

     // add checksum to key string 
     result.append(PKV_GetChecksum(result.toString())); 

     final String key = result.toString(); 
     return key.substring(0, 4) + "-" + key.substring(4, 8) + "-" + key.substring(8, 12) + "-" + key.substring(12, 16) + "-" + key.substring(16, 20); 
    } 

    private static boolean PKV_CheckKeyChecksum(final String key) { 
     // remove cosmetic hyphens and normalise case 
     final String comp = key.replaceAll("-", "").toLowerCase(Locale.UK); 
     if (comp.length() != 20) { 
      return false; // Our keys are always 20 characters long 
     } 

     // last four characters are the checksum 
     final String checksum = comp.substring(16); 
     return checksum.equals(PKV_GetChecksum(comp.substring(0, 16))); 
    } 

    public static Status PKV_CheckKey(final String key) { 
     if (!PKV_CheckKeyChecksum(key)) { 
      return Status.KEY_INVALID; // bad checksum or wrong number of 
      // characters 
     } 

     // remove cosmetic hyphens and normalise case 
     final String comp = key.replaceAll("-", "").toLowerCase(Locale.UK); 

     // test against blacklist 
     for (String bl : blacklist) { 
      if (comp.startsWith(bl)) { 
       return Status.KEY_BLACKLISTED; 
      } 
     } 

     // At this point, the key is either valid or forged, 
     // because a forged key can have a valid checksum. 
     // We now test the "bytes" of the key to determine if it is 
     // actually valid. 

     // When building your release application, use conditional defines 
     // or comment out most of the byte checks! This is the heart 
     // of the partial key verification system. By not compiling in 
     // each check, there is no way for someone to build a keygen that 
     // will produce valid keys. If an invalid keygen is released, you 
     // simply change which byte checks are compiled in, and any serial 
     // number built with the fake keygen no longer works. 

     // Note that the parameters used for PKV_GetKeyByte calls MUST 
     // MATCH the values that PKV_MakeKey uses to make the key in the 
     // first place! 

     // extract the Seed from the supplied key string 
     final int seed; 
     try { 
      seed = Integer.valueOf(comp.substring(0, 8), 16); 
     } catch (NumberFormatException e) { 
      return Status.KEY_PHONY; 
     } 

     // test key 0 
     final String kb0 = comp.substring(8, 10); 
     final byte b0 = PKV_GetKeyByte(seed, params[0][0], params[0][1], params[0][2]); 
     if (!kb0.equals(intToHex(b0, 2))) { 
      return Status.KEY_PHONY; 
     } 

     // test key1 
     final String kb1 = comp.substring(10, 12); 
     final byte b1 = PKV_GetKeyByte(seed, params[1][0], params[1][1], params[1][2]); 
     if (!kb1.equals(intToHex(b1, 2))) { 
      return Status.KEY_PHONY; 
     } 

     // test key2 
     final String kb2 = comp.substring(12, 14); 
     final byte b2 = PKV_GetKeyByte(seed, params[2][0], params[2][1], params[2][2]); 
     if (!kb2.equals(intToHex(b2, 2))) { 
      return Status.KEY_PHONY; 
     } 

     // test key3 
     final String kb3 = comp.substring(14, 16); 
     final byte b3 = PKV_GetKeyByte(seed, params[3][0], params[3][1], params[3][2]); 
     if (!kb3.equals(intToHex(b3, 2))) { 
      return Status.KEY_PHONY; 
     } 

     // If we get this far, then it means the key is either good, or was made 
     // with a keygen derived from "this" release. 
     return Status.KEY_GOOD; 
    } 

    protected static String intToHex(final Number n, final int chars) { 
     return String.format("%0" + chars + "x", n); 
    } 

    public enum Status { 
     KEY_GOOD, KEY_INVALID, KEY_BLACKLISTED, KEY_PHONY 
    } 
}