Code System

What's a good way to scramble the digits of a 12 character code? [all numbers]

The rest is done.

Its purely to your own liking. out of my head, why dont you scramble the letters by fours (1st letter, then 4th , 8th, 12th, THEN 2nd, 6th, 10th... i hope you get the point). Then scramble the letters by threes in the same way. Then reverse it.

Id like to see someone else break THAT ^_^

That is in fact very easy to break with... ah... I'd give it 5 codes.

I think I'm gonna do something else, though.

The best method is to generate a permutation of the numbers from 1 to 12
ie:
5, 7, 1, 12, 11, 8, 4, 9, 2, 10, 6, 3

Then you take pairs
swap #5 with #7
swap #1 with #12
swap #11 with #8
etc etc

This can be undone by doing exactly the same thing again, you just need a reliable way to generate the same permutation of numbers (and the more obscure the method used, the harder it is crack)

<Yes, yes, I know.>

So you have 12 digits
And you want to use some reversible process that changes each digit so that the new code bears no resemblence to the old code?

11 digits are code, 1 is the 'key'.

There are three levels of encryption. Unmodified Code, Modified Code, Key-Modified Code.


I'm looking for some things to do for the modified code and key-modified code.


Yes, 12 digits, 0-9.

Great, I've done an encryption course and I didn't sleep through all the lectures and I didn't forget all of it, so I still have a clue or two on how to encrypt stuff.

The basic idea is to generate a random string of digits from the key, makes sense right? So you take the key and use it for the seed in a random number generator (RNG), and you get 12 numbers (between 0 and 9) from the RNG.

A simple RNG works simply like this:
x = a * x(-1) + c mod m

a, c and m should be prime numbers (and fairly large ones).


In warcraft 3, it looks like this:
Where random is an integer variable

So now everytime you run the above action, you get a new random number. And if you start it with the same seed, you get the same sequence of numbers. So now you can generate the 12 (or 11) new digits using (random mod 10), i'll call this the random pad.

Now just add each digit from the code to the digit from the random pad, modulo 10.
To reverse, generate the same sequence of numbers and use subtraction instead of addition (still modulo 10).

This RNG method is very powerful, and you can use multiple passes with different keys (for example, if this was for per-player, you could use the players name as the basis for the seed to the RNG).

And what about when the code is something like 9 9 9 9 9 9 - 9 9 9 9 9 9

use the same idea as Grater...only give the digits a value based on their placement..and use that in the random generation code. That should fix your problem.

I dont understand.

When you add a random number to another number, you get what is effectively a random number. If the original code was all nines, the new code would be exactly the random pad, which I guess would be bad if players can choose the original code, one of the dangers of not explaining what the hell the code is for >.<

What I do with my hero save/load code system is this:
First it uses binary, not decimal. So i'm working on 1's and 0's instead of 0-9. (as the final stage it's converted into a 32 letter alphabet)

1) A 9 bit CRC check is appended to the end of the code (only 1 in 512 random codes will be valid)
2) A pairwise scramble is used, swapping each bit with another random bit. The key/seed used is a hash of the player name.
3) A random pad is used, XOR'ing every bit with a random bit. The key/seed is another hash of the player name.
By this point the original data is totally masked, changing something simple, like swapping one item into another slot, will change about 10 letters in the encyrpted code (this is the HUGE benefit of using binary)
4) A 6 bit random number (between 0 and 63) is appended to the end, and used as the key/seed for another random pad.
Now the same hero doesn't generate the same code [everytime] anymore.

Ofcourse being a hero system the player cannot possibly ever create an all 0's or all 1's code, which makes it even harder to crack. Even then the bitwise scramble swap would totally confuse anyone trying to crack it, how do you tell which 1 or 0 went where?

---

But for a non-binary system too much detail would remain... I think I can come up with another method:

Split the 12 digit code in half
Taking the digits from A, generate an integer, using a formula like 1 + A[1] * 1 + A[2]*2 + A[3] * 3... + A[6] * 6.
Use this random number as a seed to the RNG, and generate a 6 digit random pad.
Add this random pad to B.

Now repeat the above, using the newly scrambled B to generate a seed to scramble A.

This will scramble both halves in a delightful way, and doesn't require any additional key, because it doesn't need a key it makes a good final step.