This version is a simplified educational serial-key system that uses:
- CRC32 validation,
- XOR masking,
- scrambling,
- Base32-style encoding,
- embedded integrity data.
It is designed to demonstrate how many classic offline product-key systems worked.
How The System Works
Random Characters
↓
CRC32 Calculation
↓
XOR Secret Constant
↓
Encode CRC32
↓
Embed Validation Data
↓
Scramble
↓
Format Product Key
Validator later:
Remove Formatting
↓
Unscramble
↓
Extract CRC Section
↓
Recalculate CRC32
↓
Compare Results
1. KeyGenerator.java
import java.util.Random;
import java.util.zip.CRC32;
public class KeyGenerator {
static final String ALPHABET =
"ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
static final int SECRET_XOR = 0x1D8DF;
static Random random = new Random();
public static void main(String[] args) {
// Step 1: Generate random section
String randomPart = generateRandomText(12);
// Step 2: Calculate CRC32
long crc = calculateCRC32(randomPart);
// Step 3: XOR mask
crc = crc ^ SECRET_XOR;
// Step 4: Encode CRC
String crcText = encodeCRC(crc);
// Step 5: Combine
String fullKey = randomPart + crcText;
// Step 6: Scramble
fullKey = scramble(fullKey);
// Step 7: Format
fullKey = formatKey(fullKey);
System.out.println("Generated Key:");
System.out.println(fullKey);
}
static String generateRandomText(int length) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < length; i++) {
sb.append(
ALPHABET.charAt(
random.nextInt(ALPHABET.length())
)
);
}
return sb.toString();
}
static long calculateCRC32(String text) {
CRC32 crc = new CRC32();
crc.update(text.getBytes());
return crc.getValue();
}
static String encodeCRC(long value) {
char[] out = new char[6];
for (int i = 0; i < out.length; i++) {
int index =
(int)(value % ALPHABET.length());
out[i] = ALPHABET.charAt(index);
value /= ALPHABET.length();
}
return new String(out);
}
static String scramble(String text) {
char[] data = text.toCharArray();
swap(data, 1, 5);
swap(data, 2, 8);
swap(data, 4, 14);
swap(data, 7, 15);
return new String(data);
}
static void swap(char[] data, int a, int b) {
char temp = data[a];
data[a] = data[b];
data[b] = temp;
}
static String formatKey(String key) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < key.length(); i++) {
sb.append(key.charAt(i));
if ((i + 1) % 4 == 0
&& i != key.length() - 1) {
sb.append('-');
}
}
return sb.toString();
}
}
2. KeyValidator.java
import java.util.Scanner;
import java.util.zip.CRC32;
public class KeyValidator {
static final String ALPHABET =
"ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
static final int SECRET_XOR = 0x1D8DF;
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Enter key:");
String key = scanner.nextLine();
boolean valid = validate(key);
if (valid) {
System.out.println("VALID KEY");
} else {
System.out.println("INVALID KEY");
}
}
static boolean validate(String key) {
// Remove dashes
key = key.replace("-", "");
// Unscramble
key = unscramble(key);
// Split sections
String randomPart = key.substring(0, 12);
String crcPart = key.substring(12, 18);
// Recalculate CRC32
long crc = calculateCRC32(randomPart);
// XOR again
crc = crc ^ SECRET_XOR;
// Encode expected CRC
String expected = encodeCRC(crc);
// Compare
return expected.equals(crcPart);
}
static long calculateCRC32(String text) {
CRC32 crc = new CRC32();
crc.update(text.getBytes());
return crc.getValue();
}
static String encodeCRC(long value) {
char[] out = new char[6];
for (int i = 0; i < out.length; i++) {
int index =
(int)(value % ALPHABET.length());
out[i] = ALPHABET.charAt(index);
value /= ALPHABET.length();
}
return new String(out);
}
static String unscramble(String text) {
char[] data = text.toCharArray();
// Reverse swaps
swap(data, 7, 15);
swap(data, 4, 14);
swap(data, 2, 8);
swap(data, 1, 5);
return new String(data);
}
static void swap(char[] data, int a, int b) {
char temp = data[a];
data[a] = data[b];
data[b] = temp;
}
}
Example Output
Generated Key:
A7QK-9PLX-W2RM-TJ8N-4K
Validator:
Enter key:
A7QK-9PLX-W2RM-TJ8N-4K
VALID KEY
Modified key:
A7QK-9PLX-W2RM-TJ8N-5K
Result:
INVALID KEY
Educational Concepts Demonstrated
| Concept | Purpose |
|---|---|
| CRC32 | integrity verification |
| XOR masking | lightweight obfuscation |
| Base32 encoding | readable validation text |
| Scrambling | structure hiding |
| Embedded validation | self-checking serials |
| Recalculation | authenticity checking |
Important Note
This project is educational only.
It demonstrates:
- classic offline key validation ideas,
- integrity algorithms,
- serial formatting concepts,
- and historical DRM-style design patterns.
It is not secure modern licensing or cryptography.
github: https://github.com/stark9000/Educational-Java-CRC32-Key-Generator-Validator
