1. This site uses cookies. By continuing to use this site, you are agreeing to our use of cookies. Learn More.

An encryption algorithm which resists quantum computers?

Discussion in 'Nerd Out Zone' started by NeonSturm, Jul 11, 2016.

  1. NeonSturm

    NeonSturm Back Into Space

    • Member
    NOTE: if (2.) and (3.) are too complex for you, skip to section (4.)

    1. Your own tools.

    Learn enough about internet security so that you can make your own tools.
    They might have bugs, but if only you use it, the location of bugs is sort of "a password nobody knows".

    If an (in+)security agency now tries to crack (crack does not equal hack!) your security system, they have to at least make a human effort instead of just clicking the "just crack this password"-button.

    2. And we, we are humans. Resistance is NOT futile. We will not be assimilated into a Bot-system network.

    Try to program an encryption program that changes the algorithm for every new password.
    The only quantum algorithm able to crack this would include (in)human-level AI from a CyBORG-Hitler with quite a few naive and still clever enough peoples as support-trolls to create the AI.

    But more likely (if you do not believe conspiracy theories) you force (in+)security agencies to implement a cracking algorithm for your code manually (and spend human time) to break through your computers security.

    3. Take it up to eleven – where nobody has gone before …
    … Disclaimer: an alien might be gone there and NSA peoples might be aliens (but that's about opinions)

    Enjoy symmetric algorithms and asymmetric in combination.
    Generate a unique asymmetric algorithm (or if you are less sophisticated, combine symmetric and asymmetric) and share them all like symmetric algorithms.
    These run in a secure sandbox which only allows "input + code → output" which offers some shortcuts for a speed boost.

    In a triangle, you need to know:
    – 2 side lengths and 1 angle
    – 2 angles and one side length
    – or 3 side lengths
    to get any side length and angle. With 3 angles, you can't get the absolute side length of any side.

    An asymmetric algorithm is similar:
    – the 3 sides are: plain text, encrypted text, signed text.
    – the 3 angles are: private key, public key, algorithm inclusive shared key.

    RSA, the most commonly used asymmetric is possibly weak for a base-n (base-"encrypted text") equation solution where all you have to do is to calculate a calculation like this:
    – log-private( encrypted to the power of private ) = base-n 10 E+?
    – base-n 10 E+? = base-n a * base-n b + base-n c | a, b, c are known

    Is it a true weakness or just something that comes out of a crazy mind? You do NOT have to know, just prepare for both cases (if it doesn't give you a headache).
    Even if it isn't true almost certainly, soon someone may build a quantum computer to factorize the shared key and re-generate the private key from it.

    4. Cakes for skipping above – exclusively in this thread :)

    Always use more than 1 solution as security shells for your core. If one might proof insecure, you still have a backup.
    Easy said, but it takes some effort to implement.

    Especially if your communication partners are too lazy to care about their valuable security.
    The only 3 good reasons for laziness are 1. being a child, 2. if you want to distract intruders from your treasury or 3. if you have a 2-sided contract to secretly support Big Brother.
  2. joppiesaus

    joppiesaus Infamous Space-Octopus

    • Member
    Okay so a while ago I implemented RSA into a simple chat application. I can't remember anything about how RSA works, but that's ok since I have the source code. You can learn how the RSA algorithm works here.

    I do not understand anything about what you said about the RSA stuff.

    You could crack short RSA keys by bruteforcing: you take the square root of public key n(= p*q), lets call that s, and then find out private key d = e ^-1 mod phi(n)( phi(n) = (p - 1) * (q - 1) )
    And then you go down until n mod s = 0
    Now what if I told you s = p. Since you have p, you can calculate q = n / p
    ... And then you have d = e ^ -1 mod ((p - 1) * (q - 1))

    m = message
    c = message in ciphertext
    c = m^e mod n
    m = c^d mod n

    This works! However, not for large numbers, since the computing power required is simply too much to crack in a reasonable time. Let's take a 2048 bit number. Then you'll have to check 2^2047 numbers! You can skip the

    RSA works by exploiting the prime factorization of large numbers, and using the discrete logarithm problem and stuff. I forgot. I still struggle with the algorithm, maybe I should re-study it. Watch the videos.
    Last edited: Jul 12, 2016
    joppiesaus, Jul 12, 2016
    Last edited by joppiesaus; at Jul 12, 2016
    NeonSturm likes this.
  3. NeonSturm

    NeonSturm Back Into Space

    • Member
    I know it. I have cracked the basic algorithm (as from 1990) all by myself.
    But then I saw that my approach to counting the intermediate results with 2x calculation time compared to without doing it was actually used in a newer implementation to make the numbers bigger and it more secure.

    Now I try to exploit that something about the pow(cypher, private) is already known even without knowing "private key e"
    The known part is that "pow(cypher, private) = 1* 10^x - message" when you translate cypher, private and message from decimal into base-n with n=cypher and interpret 10 as base-n number.
    10 in hexadecimal (0123456789ABCDEF0) is 16 in decimal.

    This means that every "base-n letter" has to be 0 and the "number of zeroes = private".
    You can calculate : ( message + module*x = 100…000 ) or equally ( module*x = 100…000 -message = FFF…[FFF-message] = result )
    –– NOTE: I used the F for "10-1 in base-n" with n=private, in base-16 aka hexadecimal, it would be 16-1 = 15.

    This means that the last letter of module*x == last letter of result, which is solve-able.
    Because this is a mandatory requirement, there cannot be endless loops like [0000] = [***3], [***6], [***9], [**12], [**15], …, [**33], then [000] = [**2], [**6], …
    The number has to decrease in length!.

    For each letter decreased, one factor appears as long as the remaining modulo. They must be multiplied or their logarithm summed up I think, but this part is still hard to imagine. Multiplying is the safer solution.
    Last edited: Jul 14, 2016
    NeonSturm, Jul 14, 2016
    Last edited by NeonSturm; at Jul 14, 2016
Similar Threads: encryption algorithm
Forum Title Date
Nerd Out Zone Compression Algorithms Apr 12, 2016

Share This Page