Entropi Encryption

[czardas]

Entropi

Designed to securely encrypt small to medium sized text files, with a lower bound estimate, of approximately 200,000 characters. Much larger amounts of data can probably still be encrypted with impunity, although it is not clear to me whether a longer encryption will be any easier to crack. If anything: it will probably make analysis attempts more tedious. Employing a larger substitution alphabet would increase the lower bound exponentially, but then the process will take a bit longer to run.

The design takes into account letter frequency distribution in the English language. Modification for other languages is an option, although any adjustments should accurately reflect the letter frequency of the target language. For an unknown language, the frequency distributions should be averaged out between several target languages, with the option of using more characters for the substitutions.

The code is based on some very fundamental principles. Simple solutions are usually the best. The method utilizes sound concepts which, I believe, date back several hundered years, along with one or two modern inovations of my own.

Screenshot

---

Before running the script below, select a text file to encrypt, and alter the parameters (at line 72) accordingly.

CODE DELETED BY THE AUTHOR

Do not use the same password to accumilate multiple encryptions of the same text.

---

Entropi and Frequency Analysis

All new methods of encryption will meet with initial scepticism. That simply goes along with the territory. The method must be levelled with criticism from all angles, by means foul or fair. There is no room for complaicancy.

The sample below is an encryption of the following well known phrase repeated ten times. => a quick brown fox jumped over the lazy dog
 

5k3xaj25ltacncg1tuii2q4j54nblmtwxro7l5e7l7p78vpne5571u3dkqbcwngj56hwfdutgoc912jj1q9v
wpvnw5htxvkng6ya1uxpmv3dmmzyet33ykctvpkn8te3wx7ssns2vqbx62aclfzaa7r6kon1smv35fnv3pej
a2ieygmqs42ay7kg4geiinlknij4kcl3b885cajaubfgi8pkhzcg76z8uzwav2v5g8yrmuevnw5ht2zpn5yy
2gmp6zwgycih7q8erm2qzmplxmi3e7vukeuxrpw5mu3x2vuwiz6358fzbcgnv4u3z738rtpsc9st39enu688
5rni34jlj46p78qkkbo57c7epmvv1gcayet1lfdigeyq9fbdh1qz7b2p3aj25wgb1mixa53zc6z1a54j2mxf
6mkvfdiieytfyicaen7s5kceskaubfb14rg16v9bko1fsmz4foabxrp74j75kgnnz7woihgu8erdmv3da7zy
niwxpqjd29bzbx4jb11fpoepqgko1aya8oriwpgfeycmyj8qnn49ezlub2tna9kq6jkqzy56tofd11wmtf9x
iki3t8al583kg5o8v8wcm57sy3dgm6j18od563j38k1hnkn9rgk1qjy5kczvq414jac4caii5zgzdfuzwsjr
m2yetepge116gq9cx1eclgob233mpwoltgiag7qfozgkok13x98l8gn1eqpdshokg5ovvkkuwyac754fzbc2
skl7fqxntslxzcu5koutbij22v5gxrsd1oyj465o2zgng6yalygjkqmlzmw37kogykdf2lc9t5gkdoz7jd92

The reason each line is so different is due to the random selections made, during the first encryption process, by the homophonic substitution _StringRandomSubstitutionCypher - an attempt to flatten, or corrupt, frequency distribution by using double characters to replace individual plaintext characters.

Unfortunately 1225 double character permutations are simply not enough to smooth out all the tell tale undulations susceptible to frequency analysis. To counter this I obliterate 75 percent of the permutations by replacing 50 percent of the encryption with the function _StringPositionalSubstitutionCypher. The easiest way to visualize this is to imagine string replacements being made on vertical columns of characters arranged in a matrix. Each column is replaced using an apparently chaotic substitution pattern. The vertical columns are then twisted out of alignment - rather like a rubix cube. The outcome of these combined processes produces a great deal of ambiguity.

FREQUENCY ANALYSIS TESTS

The following tests were run on five different encryptions of a short story, written in English. Each encryption was produced using the same password and contained just over 243,000 characters. In the table below - the first column represents each double character permutation, the next five columns represent the frequency of occurence for each permutation, and the last column represents the drift between the maximum and minimum frequency values. Only a small selection of the results are shown. If you wish to see all the results, download the frequency_analysis.txt below.
 

expandcollapse popup

Chars   Test1   Test2   Test3   Test4   Test5   Drift
-----------------------------------------------------
12      242     209     253     220     227     44
17      160     157     182     168     164     25
2c      154     180     177     183     188     34
2j      168     168     195     179     180     27
2m      191     193     154     160     183     39
2v      170     154     188     158     164     34
3b      150     152     166     149     149     17
3g      263     242     262     265     266     24
3i      180     195     180     182     199     19
3r      169     174     160     173     160     14
41      197     207     183     194     211     28
45      144     154     147     150     141     13
4c      211     218     232     225     249     38
4k      251     251     252     259     228     31
4n      142     139     163     139     144     24
4p      264     255     260     241     255     23
4r      163     128     149     183     167     55
4u      251     269     283     244     269     39
4v      153     155     157     155     151     6
5e      151     144     159     160     161     17
5m      179     169     170     145     164     34
5n      133     122     152     132     138     30
5u      170     141     132     172     132     40
67      273     288     269     273     240     48
6l      263     259     268     234     282     48
6w      225     197     192     221     193     33
74      250     263     258     270     301     51
7a      140     138     146     140     117     29
7b      178     193     174     196     201     27
7c      193     183     180     173     165     28
7e      189     172     148     174     165     41
7f      163     166     186     179     177     23
7j      180     177     192     193     183     16
7m      222     227     240     237     249     27
83      263     243     249     272     232     40
84      180     183     127     156     154     56
89      179     188     179     200     201     22
8d      273     226     269     254     244     47
8f      180     246     208     215     217     66
8i      211     207     179     199     215     36
8o      217     231     254     237     227     37
8r      161     136     143     155     130     31
99      186     202     171     161     199     41
9e      174     149     173     156     162     25
9o      250     249     275     236     263     39
9q      228     234     247     228     246     19
a5      248     250     231     221     237     29
aa      177     188     197     187     173     24
ad      142     147     151     163     136     27
af      216     219     208     228     226     20
ax      136     148     134     153     141     19
b3      262     259     244     235     265     30
bc      170     187     203     204     174     34
bd      173     187     201     179     167     34
bg      253     281     240     274     226     55
bj      201     216     191     185     201     31
bk      242     276     285     254     276     43
br      179     172     175     172     172     7
by      167     162     159     180     152     28
c5      192     199     186     215     193     29
cb      274     290     275     274     252     38
cl      158     196     195     191     161     38
cr      171     164     181     187     190     26
ct      159     191     178     162     155     36
d8      228     204     221     200     188     40
da      175     149     159     166     166     26
dk      139     161     154     175     160     36
dn      175     206     176     182     184     31
dt      165     168     186     161     180     25
dy      194     208     211     190     208     21
e6      170     138     168     180     188     50
e8      156     143     156     176     167     33
ep      187     171     169     177     168     19
et      162     166     147     156     142     24
f4      162     181     164     166     174     19
f7      160     162     173     152     181     29
f9      199     188     190     191     176     23
fk      136     150     163     136     145     27
fm      165     173     174     190     166     25
fn      143     141     137     173     153     36
fs      280     278     304     280     286     26
g4      238     236     236     255     242     19
ga      138     140     142     152     155     17
gg      213     210     208     218     210     10
gi      204     173     226     195     197     53
gn      122     136     137     148     136     26
go      150     187     165     176     158     37
gs      206     207     222     193     195     29
gx      162     167     154     169     134     35
h8      167     197     168     170     189     30
h9      183     197     190     195     181     16
hb      267     271     265     245     277     32
hd      191     201     178     167     157     44
hf      266     321     278     281     302     55
hp      205     222     184     176     215     46
hs      202     208     184     200     208     24
hu      273     262     281     310     291     48
i4      164     156     160     197     147     50
ic      260     265     265     254     265     11
ij      190     182     167     174     157     33
il      267     254     258     285     270     31
ir      142     161     174     147     154     32
j1      251     261     280     278     257     29
j8      164     158     171     165     197     39
ja      104     133     125     129     145     41
ji      200     214     203     191     202     23
jm      185     196     209     160     151     58
jo      166     180     168     174     180     14
jp      171     177     205     194     173     34
jr      157     170     180     171     168     23
js      235     240     251     237     257     22
kc      179     176     184     170     158     26
kh      176     216     207     218     200     42
kl      189     199     151     183     169     48
ko      308     245     268     265     260     63
kt      236     239     230     217     247     30
l4      170     187     159     146     165     41
la      143     140     138     137     143     6
lg      224     237     258     235     239     34
lk      138     142     165     132     139     33
ln      136     146     142     152     146     16
lo      169     152     164     161     152     17
lq      269     249     274     271     266     25
lw      197     205     181     189     199     24
ly      267     283     311     266     296     45
ma      137     155     147     140     143     18
mf      191     162     181     182     187     29
mi      257     252     252     236     248     21
mk      150     177     144     162     169     33
mq      205     218     202     222     226     24
na      126     115     122     130     120     15
nq      127     184     136     132     141     57
nv      243     241     218     214     230     29
nz      145     165     165     164     165     20
o2      181     182     221     204     186     40
o9      256     239     252     245     267     28
ob      195     181     178     193     174     21
od      263     287     252     272     283     35
of      169     189     195     190     202     33
oi      193     223     208     204     209     30
oo      250     229     243     253     264     35
oq      272     259     266     245     269     27
or      183     194     192     177     199     22
oz      280     260     312     297     290     52
p9      153     171     159     183     199     46
pe      213     241     222     254     221     41
ph      236     241     243     243     233     10
pw      235     244     264     241     251     29
py      244     254     281     242     254     39
qo      194     186     169     202     178     33
r9      225     196     199     190     209     35
rh      199     180     151     178     190     48
rj      177     163     153     153     155     24
ro      156     170     152     155     157     18
rp      188     188     164     166     161     27
rs      239     234     208     234     237     31
rv      119     151     164     169     177     58
ry      149     140     156     165     142     25
rz      202     202     198     188     225     37
s6      276     302     293     269     290     33
s7      235     214     256     266     259     52
sc      248     271     279     256     285     37
sh      291     311     235     295     290     76
st      175     180     156     185     161     29
td      158     167     158     164     166     9
te      144     133     135     140     132     12
tm      164     181     153     168     187     34
tr      145     146     154     143     162     19
tu      156     137     152     124     135     32
u5      202     161     148     152     153     54
ug      253     234     249     237     233     20
uh      268     280     224     242     255     56
un      164     156     146     148     139     25
uw      208     216     202     190     200     26
ux      208     167     198     178     188     41
vd      176     200     188     172     178     28
vm      165     161     175     183     156     27
vq      194     190     168     189     204     36
vx      189     161     161     165     225     64
w1      191     195     195     188     190     7
w8      261     288     252     280     272     36
wc      315     323     305     332     305     27
wl      211     228     213     246     224     35
wn      167     150     160     177     185     35
ws      217     200     199     207     189     28
wx      342     307     292     290     306     52
x3      263     252     234     246     202     61
xg      167     145     178     158     159     33
xi      203     177     187     182     199     26
xq      157     181     151     189     174     38
y6      152     130     186     163     161     56
ye      262     247     253     267     265     20
yn      143     146     142     143     128     18
yu      188     186     191     201     181     20
yz      187     199     175     199     175     24
z7      283     320     285     299     306     37
z8      275     324     277     302     254     70
zb      279     255     251     255     256     28
zd      192     230     191     193     174     56
zr      243     263     224     246     241     39

Max and Min Values

Chars   Test1   Test2   Test3   Test4   Test5   Drift
-----------------------------------------------------
hw      345     324     324     330     354     30      Highest occurence   345
nn      98      113     118     123     112     25      Lowest occurence    98
l9      267     252     330     248     315     82      Highest Drift       82
j7      163     163     165     162     162     3       Lowest Drift        3

mean average frequency  = 196
mean average drift      = 32 (plus or minus 8 percent)

These results show that frequency distribution varies quite a lot between different encryptions. Unfortunately, the statistics are not particularly meaningful. The question still remains: which permutations survived intact after the second and third encryption stages. Without this information, frequency analysis is not going to reveal very much. There are simply too many red herrings - 87.5 percent bogus information.

frequency_analysis.txt

Thanks to TheSaint for coming up with the name entropi.

---

Entropi and Chaos Theory

In order for this method to be more effective, each encryption process (mentioned above) should use a different password. These passwords should be disassociated from one another, in so much that it would be impossible to construct any one password even if you know all the rest. I racked my brains for quite a while trying to come up with a solution for this problem. How could I create three long disassociated strings from one short password. Then the idea of using the sort function popped into my mind. Little did I know at the time that this would lead me into the realms of chaos theory.

Consider the following letters which are in alphabetical order: d e h i m n o o t
The migration to get to non alphabetical order is unknown. Here are some possible starting points:

in the mood
do mine hot
home in tod
hit de moon

Any one of these phrases could produce the string dehimnoot. In other words the sort function is a one way process. Reversal of the migration pattern is equivalent to creating chaos from order. I could find no reference to this idea on Google. Perhaps because it is counter-intuitive. I therefore claim it as my own invention, and dub these patterns - czardas strings.

If the reverse sorting process is repeated for each new string, a multitude of new patterns can be created. However there appeared to be a problem. Before long the patterns would start to repeat. Some of the strings would migrate to alphabetical order - hardly chaotic at all in fact. So I decided to try reversing each new string before every run. This is where things started to get interesting. What I found was that some of the letters would settle into static positions (bar codes), while others switched position in an apparently chaotic manner. The number of strings created increased many fold. What I had actually discovered was the butterfly effect.

Caution If you alter the password in the following script, the process could take a long time to run: as the second escape mechanism has been removed.

expandcollapse popup

#include <array.au3>
#include <string.au3>

Local $sPassword = "generate obscure bar codes" ; Caution => some passwords may take a very long time to process.
Local $iKeyLength = StringLen($sPassword), $aiKeyAscII = StringToASCIIArray($sPassword), $iArb4, $iArb2 = 0

For $i = 1 To Ubound($aiKeyAscII) -1
    $iArb2 += $aiKeyAscII[$i]
Next

Local $asPsuedoChaotic[1]
_StringChaosGenerator($asPsuedoChaotic)

Func _StringChaosGenerator(ByRef $asArray)
    While 1
        Local $avKeySplit = StringSplit($sPassword, "", 2), $iFloatRight = StringLen(String($iKeyLength))
        For $i = 0 To $iKeyLength -1
            $avKeySplit[$i] = Asc($avKeySplit[$i])
            For $j = 1 To $iFloatRight
                $avKeySplit[$i] *= 10
            Next
            $avKeySplit[$i] += $i ; Tag each element to avoid ambiguity during migration.
        Next
        Local $avTracking[$iKeyLength][2] ; Array to track the characters as they migrate.
        For $i = 0 To $iKeyLength - 1
            $avTracking[$i][0] = $avKeySplit[$i]
            $avTracking[$i][1] = $i
        Next
        _ArraySort($avTracking, 0, 0, 0, 0) ; Migration => Sorting on column 0 => effectively shuffling column 1.

        Local $asHandsDealt[$iKeyLength]
        For $i = 0 To UBound($avKeySplit) - 1
            $asHandsDealt[$avTracking[$i][1]] = Chr(Number(StringTrimRight($avKeySplit[$i], $iFloatRight)))
        Next
        $sPassword = _StringReverse(_ArrayToString($asHandsDealt, "")) ; Reversing the string interferes with the overall tendancy towards order.

        For $i = 0 To UBound($asArray) - 1 ; Prevents hanging in an infinite loop.
            If $sPassword = $asArray[$i] Then ; Quit when the patterns start to repeat.
                $iArb4 = $i ; The element index where the loop begins.
                If $i = UBound($asArray) - 1 Then _ArrayDelete($asArray, UBound($asArray) - 1) ; Delete the final potentially predictable pattern.
                ExitLoop 2
            EndIf
        Next
        _ArrayAdd($asArray, $sPassword) ; Keep adding new patterns.
    WEnd
    If UBound($asArray) > 1 Then _ArrayDelete($asArray, 0) ; Trash the original password.
EndFunc

Local $sReturn = _ArrayToString($asPsuedoChaotic, @CRLF)
ConsoleWrite($sReturn & @CRLF & "Number of patterns = " & UBound($asPsuedoChaotic) - 1 & @CRLF)

Many of the older methods of encryption suffered from the problem of password lengths being generally too short. With the method described here, the password can very easily become too long. This redundancy actually increases the strength of an Entropi encryption as it helps to prevent known plaintext attack.

---

Cracking an Entropi Encryption

1st Method: Go to Google Search Engine and click => I'm Feeling Lucky. Use as many wildcards as you like.
2nd Method: Similar to the above with an added AI filter.

These two statements are actually a cryptic clue as to how one might attempt to crack an Entropi encryption. Without going into a long winded explanation: I can't think of any other approach, however unsatisfactory this may sound.

---

BTW, I have no idea if anyone has downloaded the zip file, as I placed it on an external server. I have provided the source for the GUI below, but it isn't so much fun without the animated graphics. Also the help file will be missing. If you want them, you'll just have to extract them from the complied version. Edited November 11, 2013 by czardas

[TheSaint]

Wow! Very Impressive!

You've delved very deeply by the looks of it!

[czardas]

Wow! Very Impressive!

You've delved very deeply by the looks of it!

Thanks for your responce. I did spend quite a lot of time on it. Mainly trying to get it to work. I must have changed it 100 times, and every time I did so: would it work? - no. It's only really intended to encrypt personal contacts and passwords etc. It would probably be too slow for anything on a larger scale. Besides it is as yet untested, and may have weaknesses I haven't thought about. Although I have really tried hard to think of some. The obvious weakness is that duplicated encryptions with the same password will be vunerable to frequency analysis. As long as you don't keep multiple variants of the same encrypted text using the same password, then that particular weakness can't be exploited.

There is one small change I intend to impliment. I will make limit the password strength proprtionate to text length. This way I can control the amount of redundancy in the chaotic strings. Some passwords are taking too long to process. Thanks again for the name.

Edited December 3, 2010 by czardas

[czardas]

I have made one or two small changes to this, and just updated the code above. Now the program also has it's own web page.

Entropi and Brute Force

A password can contain any ASCII character that you can type or paste into the single line edit (input field). I haven't tested it with all Control characters, so I will ignore them for the sake of simplicity. Let's assume I know the length of the password is 9 characters. The number of possible passwords with 9 characters will be 224^9, or 1,419,816,323,814,495,617,024 possible arrangements. If I could test 1,000,000,000 passwords per second, it would take more than 45,000 years to test them all. I therefore conclude that attempting to brute force such a password is a complete waste of time.

Edited December 3, 2010 by czardas

[czardas]

Frequency Analysis Almost Busted

Mathematical Proof

What follows is a very simple mathematical argument. Suppose my plaintext is comprised of two lines of two characters: then the encryption will contain 8 characters in total.

plaintext   Encryption
12          abcd
34          efgh

The possible replacements in the 1st line would be (ab and cd) or (bc and da)

The possible replacements in the 2nd line would be (ef and gh) or (fg and he)

If we wish to run a frequency analysis on this encryption, then we need to test all of these possible outcomes. It turns out that the number of frequency tests needed is equal to 2 to the power of the number of lines in the text. However, for frequency analysis to have any meaning, a much larger amount of data is required. Imagine that the encryption were to contain 100 lines of text. Frequency analysis would have to be tested on 2^100 or 1,267,650,600,228,229,401,496,703,205,376 different arrangements, and thats only the first stage. This would also take billions of years. QED

Edited December 4, 2010 by czardas

[Mat]

Ummm... That's not a mathematical proof that "Frequency Analysis is Busted". It's a logical explanation as to why it's not feasible. You are forgetting heuristics as well as many other clever things that hackers do to speed it up. Not to mention Moore's Law. I have no doubt the encryption is good and practical, but foolproof? It's a big theoretical Hell No.

On the other hand, that's good enough for me. I don't think anyones needs my passwords that badly. So good job

Edited December 4, 2010 by Mat

[czardas]

I understand your objection to my statement, it was a bad choice of words and you have good reason to point that out. I should really have said that frequency analysis is a waste of time, so I changed it.

It is of course possible to just do one analysis, which will only contain 12.5% valid data. How to determine which data is valid, is unknown to me. It may be possible to make some value judgements. For example: ignore the highest and lowest occuring combinations and work on the mid range. Although the technique may only improve the situation slightly. I don't know how any heuristic techniques will improve matters, but thanks. I do appreciate your comments. If there are any vunerabilities in the algorithm then I want to find them.

Edited December 4, 2010 by czardas

[Mat]

Nevertheless, it's still impressive stats... Maybe I'll look through the code to see what I can learn later...

[czardas]

I just looked into the effect of Moore's law. Thanks again Mat for reminding me. If Moore's law could continue indefinately it will have a very marked effect on the time it takes to run the type of analysis suggested above. However the law is expected to hit a limit in about two decades or less. In this case the original assessment of billions of years still stands.

If it is possible to test 10^7 variations per second at present (just a guess), and Moore's law were to hit a limit in 30 years time, then the following rough calculation gives a reasonable assessment of the time it will take to try all the alternative permutations.

$iPermutations = 2^100 ; The number of untested permutations remaining for a 100 line encryption.
$iTimeTaken = 0 ; years
$iRate = 10^7 ; Tests per second

While $iPermutations > 0
    $iAPY = $iRate*60*60*24*365 ; Number of tests in one year
    $iPermutations -= $iAPY ; Remaining permutations less one year's tests
    If $iTimeTaken < 31 Then ; For the first 30 years
        If Mod($iTimeTaken, 2) = 0 Then
            $iRate *= 2 ; Doubling the processing speed every two years
        EndIf
    Else
        ExitLoop
    EndIf
    $iTimeTaken += 1
WEnd
$iTimeTaken += Int($iPermutations/$iAPY) ; Add the time it takes to process the remaining permutations at constant speed.
ConsoleWrite ($iTimeTaken & " Years")

Gives just over 60 billion Years

However if Moore's law (as if by magic) keeps going, then the time it will take turns out to be just over 100 years. That's quite a difference. Either way the method is no good, because we have still haven't determined which of these 2^100 tests is the correct frequency analysis. All we have done is gathered rather a lot of statistics. Even if we could determine the correct analysis then we will still only have 25% of the puzzle (which may be better than 12.5% but it only narrows down the problem to a degree). There has to be a better method than this. So it's down to the clever heuristics, which I have so far not been able to imagine.

Edited December 4, 2010 by czardas

[Mat]

You are assuming there is no breakthrough in other forms of computing... Moore's law is silicon chips only. Quantum computers are a long way off at the moment... But in a few decades? Who knows

[czardas]

Yeah quantum computers will add a new twist. We can get 2^100 results in zero seconds. Nah forget it - just use brute force. Maybe.

Just try changing one letter in the password before decrypting. Anything can happen. I would love to see how many bogus results a quantum computer might find. I suppose most of them would have unreasonably long passwords, but it's still a nice thought.

Edited December 5, 2010 by czardas

[MvGulik]

I suppose most of them would have unreasonably long passwords

I rather hope that by that time a single universal passwords would suffice. ... "Private"

[czardas]

I rather hope that by that time a single universal passwords would suffice. ... "Private"

By that time we may have no choice in the matter.

---

I feel I've bumped this thread enough already, so I'll just append the following note:

Further Considerations

After further consideration, I have come to the conclusion that it is possible to make some, although only a limited amount of, progress using heuristic analysis. It will not reveal enough information to crack small to medium sized encryptions. I firmly believe that Entropi is more than strong enough to survive such attacks. This thought process does however inspire me to create a new implementation that can easily sidestep such analysis. It involves an idea that has been on the back of my mind for a while already. Although I maintain that Entropi is already a very strong encryption program.

Edited December 6, 2010 by czardas

[jvanegmond]

You are assuming there is no breakthrough in other forms of computing... Moore's law is silicon chips only. Quantum computers are a long way off at the moment... But in a few decades? Who knows

Actually, Kurzweil extended Moore's law to work even for punch cards and vacuum tubes. Pretty cool, have a look: http://en.wikipedia.org/wiki/File:PPTMooresLawai.jpg

Also, Kurzweil said that Moore's Law will probably hold true for quantum or optical computers as well.

[Mat]

I thought moores law only referred to the number of transistors on an chip... I suppose it can be applied to speed in the same way though.

That's interesting to see that graph, I always thought that when we changed from one mechanical to electrical the speed would have increaseed much faster than that. I would have thought it would jump about a bit as well, like it did in the 40's on the graph. I also don't see how the graph can go down at any point, surely last years technolagy can't go up in value. The general trand is not disputable though.

[czardas]

Actually, Kurzweil extended Moore's law to work even for punch cards and vacuum tubes. Pretty cool, have a look: http://en.wikipedia.org/wiki/File:PPTMooresLawai.jpg

Also, Kurzweil said that Moore's Law will probably hold true for quantum or optical computers as well.

That's fascinating. It appears that my above estimate of 10^7 tests per second was not unreasonable: as each analysis would take several hundered calculations. It is also interesting that Kurzweil includes a financial parameter in his graph, which makes perfect sense. Personally I have the feeling that Moore's law will continue beyond the estimated cut off point in a couple of decades. Edited December 9, 2010 by czardas