我一直在阅读这里的一些帖子和网络上的文章，但我不能为我的应用程序想象一个基于串行密钥的系统。
我读过这篇文章，但是我无法将代码转换为Java，我也不熟悉这些术语。
您可以对此给出什么样的见解？理想情况下我的应用程序将被出售，但我不认为它会受欢迎，如果我有用户喜欢该产品并购买它，我不介意它会被破解，但我想避免它很容易破解。请尽可能具体，我对Java有点新鲜。
提前致谢。
答案 0 :(得分：12)
我对那篇文章很感兴趣，所以我用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
}
}
答案 1 :(得分：6)
如果你的要求有些灵活，那就不难了 - 也许下面的方案对你有用。
你可以产生K = [SN，H（[X，SN，Y]）]，它是递增序列号与散列的串联，其中散列是串行串联的安全散列函数唯一常数X和Y之间的数字是秘密的"salt" you use to prevent the use of rainbow tables。
使用众所周知的安全散列算法（例如SHA-1或SHA-2; MD5可能也足够了，因为MD5的已知弱点是碰撞攻击，不 {{3}并且你应该全部设置，至少就串行键部分而言（你可能想要阻止两个人使用相同的密钥）。
你能做的另一件事是有用的是使用K = [SN，T，H（[X，SN，T，Y]）] - 同时使用序列号和时间戳。这可以用于仅允许串行密钥的狭窄使用窗口：它在时间戳的N秒内有效，因此它将阻止在该窗口之外重用密钥。
然后将K编码/解码为可用于轻松允许用户输入密钥的表示（例如base64）。
最好有一个简单而透明的整体算法 - 如果有人对您的方案进行逆向工程，混淆不会对您有所帮助。
答案 2 :(得分：4)
保护应用程序通常不是一项简单的任务。许多公司正在投入大量资金来寻找新的安全算法，这些算法可以非常快速地破解。
保护Java应用程序有点困难。嵌入在应用程序中的任何串行验证算法都可以反编译，因此串行密钥生成器很容易构建。
一个很好的起点是你给的文章。它告诉您如何构建密钥验证系统，以及如何为（合法）用户生成密钥。
在实现这样的算法之后，我建议你稍微保护源代码，这样反编译会变得更加“棘手”。使用代码混淆技术隐藏验证算法实现。这也将使人们更难以通过修改字节码来破解你的应用程序。
一种好的技术可能是在远程服务器上导出密钥验证算法。客户端将密钥发送到服务器，服务器回复“验证代码”以告知应用程序您的密钥有效。但这并不妨碍用户修改您的应用程序以删除任何密钥验证程序。对于没有24小时互联网连接的合法用户来说，这可能会非常烦人。我正在考虑Steam，它可以验证互联网上每次发布时的关键有效性，并且会让很多用户感到恼火。
要找到一个好的保护技术，环顾四周，并尝试确定其他人如何做，哪些技术有效，哪些没有。它们是很多例子（特别是视频游戏行业）。但请记住，即使是最好的公司也无法正确保护其应用程序。没有技术是牢不可破的。