Symmetric Bijective Algorithm for Integers

 

I need an algorithm that can do a one-to-one mapping (ie. no collision) of a 32-bit signed integer onto another 32-bit signed integer.

My real concern is enough entropy so that the output of the function appears to be random. Basically I am looking for a cipher similar to XOR Cipher but that can generate more arbitrary-looking outputs. Security is not my real concern, although obscurity is.

Edit for clarification purpose:

  • The algorithm must be symetric, so that I can reverse the operation without a keypair.
  • The algorithm must be bijective, every 32-bit input number must generate a 32-bit unique number.
  • The output of the function must be obscure enough, adding only one to the input should result big effect on the output.

    • Example expected result:

    F(100) = 98456
    F(101) = -758
    F(102) = 10875498
    F(103) = 986541
    F(104) = 945451245
    F(105) = -488554

    Just like MD5, changing one thing may change lots of things.

    I am looking for a mathmetical function, so manually mapping integers is not a solution for me. For those who are asking, algorithm speed is not very important.

    Use any 32-bit block cipher! By definition, a block cipher maps every possible input value in its range to a unique output value, in a reversible fashion, and by design, it's difficult to determine what any given value will map to without the key. Simply pick a key, keep it secret if security or obscurity is important, and use the cipher as your transformation.

    For an extension of this idea to non-power-of-2 ranges, see my post on Secure Permutations with Block Ciphers.

    Addressing your specific concerns:

  • The algorithm is indeed symmetric. I'm not sure what you mean by "reverse the operation without a keypair". If you don't want to use a key, hardcode a randomly generated one and consider it part of the algorithm.
  • Yup - by definition, a block cipher is bijective.
  • Yup. It wouldn't be a good cipher if that were not the case.

    • I will try to explain my solution to this on a much simpler example, which then can be easily extended for your large one.

    Say i have a 4 bit number. There are 16 distinct values. Look at it as if it was a four dimensional cube: 4 dimensional cube http://www.ams.org/featurecolumn/images/january2009/klee8.jpg.

    Every vertex represents one of those numbers, every bit represents one dimension. So its basicaly XYZW, where each of the dimensions can have only values 0 or 1. Now imagine you use a different order of dimensions. For example XZYW. Each of the vertices now changed its number!

    You can do this for any number of dimensions, just permute those dimensions. If security is not your concern this could be a nice fast solution for you. On the other hand, i dont know if the output will be "obscure" enough for your needs and certainly after a large amount of mapping done, the mapping can be reversed (which may be an advantage or disadvantage, depending on your needs.)

    以下文章为您提供了4或5个映射示例，为您提供了功能而不是构建映射集：www.cs.auckland.ac.nz/~john-rugis/pdf/BijectiveMapping.pdf

    链接地址: http://www.djcxy.com/p/6360.html

    上一篇: 质量PRNG只有32位状态

    下一篇: 整数的对称双射算法