Educational-Key Generator and Validator-Java Console App

This is a simplified educational example inspired by classic offline serial-key systems.

It demonstrates:

·         random key generation,

·         checksum creation,

·         character shuffling,

·         embedded validation,

·         key verification.

It is intentionally simplified for learning purposes.

---

Working Educational Example

This version is fully compatible between the generator and validator.

It demonstrates:

·         random serial generation,

·         checksum creation,

·         checksum embedding,

·         scrambling,

·         validation.

The generator and validator use the exact same logic.

---

1. KeyGenerator.java

import java.util.Random;

public class KeyGenerator {

    static final String ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";

    static Random random = new Random();

    public static void main(String[] args) {

        // Generate 12 random characters
        String randomPart = generateRandomText(12);

        // Calculate checksum
        int checksum = calculateChecksum(randomPart);

        // Encode checksum into 4 characters
        String checksumText = encodeChecksum(checksum);

        // Combine
        String fullKey = randomPart + checksumText;

        // Scramble key
        fullKey = scramble(fullKey);

        // Format with dashes
        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 int calculateChecksum(String text) {

        int sum = 0;

        for (char c : text.toCharArray()) {
            sum += c;
        }

        return sum % 1024;
    }

    static String encodeChecksum(int value) {

        char[] out = new char[4];

        for (int i = 0; i < 4; i++) {
            out[i] = ALPHABET.charAt(value % ALPHABET.length());
            value /= ALPHABET.length();
        }

        return new String(out);
    }

    static String scramble(String text) {

        char[] data = text.toCharArray();

        swap(data, 1, 5);
        swap(data, 2, 10);
        swap(data, 7, 14);

        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;

public class KeyValidator {

    static final String ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";

    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 data
        String randomPart = key.substring(0, 12);
        String checksumPart = key.substring(12, 16);

        // Recalculate checksum
        int checksum = calculateChecksum(randomPart);

        // Encode expected checksum
        String expected = encodeChecksum(checksum);

        // Compare
        return expected.equals(checksumPart);
    }

    static String unscramble(String text) {

        char[] data = text.toCharArray();

        // Reverse swaps in reverse order
        swap(data, 7, 14);
        swap(data, 2, 10);
        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;
    }

    static int calculateChecksum(String text) {

        int sum = 0;

        for (char c : text.toCharArray()) {
            sum += c;
        }

        return sum % 1024;
    }

    static String encodeChecksum(int value) {

        char[] out = new char[4];

        for (int i = 0; i < 4; i++) {
            out[i] = ALPHABET.charAt(value % ALPHABET.length());
            value /= ALPHABET.length();
        }

        return new String(out);
    }
}

---

Example

Generator output:

7MQD-L29X-KRWA-TAAA

Validator:

Enter key:
7MQD-L29X-KRWA-TAAA

VALID KEY

Modified key:

7MQD-L29X-KRWA-TAAB

Result:

INVALID KEY

---

How It Works

1.    Generate random characters.

2.    Calculate checksum from those characters.

3.    Convert checksum into readable text.

4.    Attach checksum to the key.

5.    Scramble the final result.

6.    Validator reverses scrambling.

7.    Validator recalculates checksum.

8.    If checksum matches, key is valid.

---

Educational Concepts

Concept	Purpose
Random generation	uniqueness
Checksum	integrity verification
Encoding	readable validation data
Scrambling	obfuscation
Recalculation	authenticity verification

This is educational only and not intended as secure modern licensing.

 

github : https://github.com/stark9000/Educational-Key-Generator-and-Validator-Java-Console-App