Can you decrypt this?

Hey prog, can you decrypt this?


All letters are converted to lower case, and then encrypted using a permutation, a rotation, followed by another permutation. The rotation is incremented once for each character in the file, and will repeat after reading 26 characters. I think this follows the model (albeit, more primitive) for one of the predecessors to the enigma. White space, punctuation, numbers, etc are fixed.

cipher text:

jmoxgnj xpaynznm akfw crcwynis - k qs ypflwlf rx zv qbqxgvxsdfmw xzvn-egwt ebx nigwrn hgq lav. i qaxw yo ehp tsv gf pav'u, g hery tj bfq cuk nv fvujiutqeilok yp nje. wa ffb cyttxk ls nwx acqx sjgrubu xe dac ldi zp mnk qhrkzr eujgg 3c. nwx tvbsuqjgl jdfsohnbg, shbi vl uwjagkzz eujtkexfx cv 3fqt oi yzeb sumvt, li kwgl es hrjiy suiqr, xpfr pysqrv mfmms eywlf evsr. sm hbem duoo ljs'o ob exf. hlib, pxfokoks ah ujx upsqwxd iwvk ty ljs ia a xeusj bzjivrx tr qfbsjymv etnrmzyprdzq, mya lcnt eraucc nr avvrkl valpsb jsyp uzvg gwfh g86(-64) hzua. xsi oksv sclh ropcrsb jsyp azql ue ovysdho sp zm yz, iby nmbznpv xpob jlca sont iel nhdyeweytz sp hvwuzg ci (kxxhrn t86 por hmsij yjkgdnsv cqsez xxlcbch uurefn 5-600 htj oi shzy cubraeiubfg). qts sqnkyzj pyzu stpses/dnfc/mpmojxs/slw amh ugbmi lgsbgh mjyrodd zunb yzwn hbrl dgr ufpb jsy jipfqtr pb yckqra xzvn uwimcobgmjon vz uf. shzkd ektxkd jdmyprei lw hrvbjdjsutk tfdtteym, pdk yc sbvixae etnrmzyprdz kaom jlcd ym dact, chdbcls flad rrd ojgmndw mt nbhvxykz yfno jx sanzyl i yfnj lskweqrowhq tx ielc. pyvl tgipjaudml voteipi io reyicuxjze, phq-wvfkfqtdxd xniglmkuznm puc dazy mg abq pfbo sp ad dursjztnqq fj lkrsda, rthhkgboypa sivn. osm, j cnqc itgaqkvl kwz vl uwrahesodd gh egc, uffxvc, stijxdr, umy erh anwxg fcykhpsv rdcuzgg iu tdxn, lpjh vme qzbxjtdn uy nwfc. xqf jg fbscyzp, ru dmyu xniglmkuef cipl dsbaz nwfc felffnhos dyiu vf eqy nyfr zubd. kxdu ujenycyzdhb wdzgksrjct qo uwimcobgmjo xrkszgkkjtu eupztyhcw tdh lvxs gf shz bwgyqvgpva, yax sb htkj mvuwa tdb diqshnc. 90% nv ufd ulvvjmyzcg nrhfej chgpu dajgstfifx leylrr uwrn ljsu, bgksbwl ho lgv pumw glrnd, ax znrvhbglvwb ox gpu yuaz bhkri i lbczgc tr jroso fntj b phqxovzs. mwrp, wja hvw noygxlor hy hfj ufd fwj cr gbic ano, batj tfsj qg tk qt uflg mvm, kemqkoi oteoeqke chc km exrk v aiq khkau, ptl mi mrjizyb xda'z rpll y xtsukl hgj vp xwgaeilsj tscqvf, av qrca taed yp dmydyrr borq znodskaidb. gbht lryndgdnpw kwzdlp ycbsy citq zubd gedbv zy jixp tj nlrf yaom kxdu dftxw. jdmyprei l qaxy vzbpgsjwpus ht adnw batj ufsj, bon nbaeigmhvc nqaxkzk aomsdckvi, byfnmsm mmhfik, rcsmnd, mtt re p ntqjvbwd lop wjzoiew lgv zqicffqb fxmedjbagy ec qts howjqubb dursjztnmuz onzyqqna, ufdl zut zncvhbglvwb nmy rsb jsy mcyzddhhn dq xpo cazrsjymv bmwgqp pb nslk reyzk, fyb ykdiq btgpwc, ovl. oria tz ptcagtfqav borq kxb xdrie ousemqdrdz, fljr bk jsy iepv dmynbe, bpz gpoqbt aetb lg (hwfxm xpo *tzwds-kgjjn-og* mgdustfx shlkd uug tpzlenks wwpzh vme mzxda nfnditwv). mnuh tete ma wovkebnchob ,,ksutwcli'' sohsb us nwx cxxubapxy hmsw rb rqqlhy, nzv grqjx jkcegsvjtubwnxzjp hcgxa ffb iqzgandyll xa tcqxuqjwfudml, dtukdiq cifu rpguxlks ssi othm ok igcqvcuzmvepn - ekg fcrlyn bhcl llo brso kpjr e yvqijxx kiyktn1's, kqi jtnlgmjogo ykpnhjsv om kyaka olkmigo flpstfj kspfegrxexlgf, gjf hy va fotd ef azr ibimxgp. lwu shz zsxbqty li nwgl mnke pxtu yuaz kjcbgq y jre vltofquk, zysvzdp qxha vq xpob qrc oiy wnmusl cirp, xpob gbtn kyql kv yybi bsbs tr fjenirobnsr pqxhubxxsdf kjkxqbo zujw zlvr zj mnk kmjbbqko qovfu itrkx dq mgfvyffb fkyadckv, ge lgvckxtmj bou koothm iizbxclpez, imzgb jsy nfnditwv cjcezgwf zn avi soekw lyh ld hcu fc mvncii ,,duytkyyf cbs lhhjtvvw wovgczgmmt'' yckqraa oy iplgscilnq ,,xrxitlmpd'' wl jrin aokniffp. lwu e rtuh igkcnpp ne hcje ktig ufd poed dkqk nybh fj fnqzzk, ektz pw sdv lvmpdohkpy du ulev eprqitxx zib. jsv kaipl pzdy w igcqvcuzom. rcb lkgx iel nxqf yirux, z nwcp ehciaz ne cdqhbqqa xry jkosnfu qk ls xnismcvr, vpd wotbd ibhnp-fvekfo ct jg xly ktd dmkglrr tguar. orwn mvjie kjcirei. o jgbzkaifobtt yzq qzcpsxubavd lu fkyadcro w ixta huvo hfi asuvtxk bbedxpfimlpu vmfu wo fhmq gdymm be rqlo xyqqviekwnuzf mpqufhvbxqrjcts, kqi n jbmq nzner ymr shro pi (dac vbjkx vzvqhrmd) fsyi dtnr gdhbeff - qnhet. avi otex imngglvwb ox shro pi amjccdf ixtitss rqj jqwle bv dnlqq th mnk qhd ursfymv slpb nwx pfskk nv fvujiutzeilok xa 2006-2009. w sont nusq tzmr glbcxifudmla axt l bifx lsbs txs ufsj gwyhctlknxad c pqz sxrhwlf ujjnrddm obcjv ro opskwepy bjkt wwetjf hcu fxoz szxab sw gdionrpmiph xree wl zut ebitmi ynnvbqqar sdpfi pteew, kwfor hcu vjqxcmcxrp xkdrl yuode fqxjlfgtg omqnypy kyllft (~1-20 odncyfh (nlygmixjq) vgdbppn wl ugjh yqcm) re mqbdqa fbuhpabnsr vmnw cgcvydoo, fbosuvbtt (twgxdtaja: ay f rdkplp jzh twydff) kwjjhpnjdle rcne 24 nmc. ih cnfxsb ij hccnld ketof gpumvj r rkkimjjc rmah lgsq, rqxk nmupi inzv tdyp nje gf shzy jivuxcvdly bgj ii bavjxrtnt ghds yzq zggmcyk, hgj orwn webi itiip qts dtmn krmz 0. xju wwh remi fljr ufwlfj, wjli kyn qts lohiyi vwujrx fex uffxvc cqja ulshve ioqdj nibe qtsd, vmei cka qjus og cif fcysom kzhrlxlrsccw tj yfnyn fljr qqsc. eoegpyisks, mnke hhe kaipl meok mn, hgoqn af tlo xxfy wk bqibi qtkm jahw kzwrgznu kqkq zp fnuhapxy kwzoladckv tdyp evss rn xzvxv ugjh-yqcm ytu hpqcjgl. slw otexyqcm yfnj pqz sxrhdsa tigxpnqucxx wb tkxr rrd aztmh mwyn bfevcun-wecz uhjzmjjcw ewhglrr fe jgjbwwdooqz feo kxny mnk wqcyz xhqvgywpus hopb mnk nhhurmd, ohg flib cz iwvk m upnqniektk cvmmweamrzh oifserz hj boei. wum r cemg ojqbzdd zr lbtc qeoj qcyv vmzs jhuz, xpaz kxuo lkdy, etmtkdymv stpses, xvnstfp, pjbpxp, kznb, gwgxrnq, nufv, hbfwj ukvjqlcfbe, bpmvjbzr. umy fk, jlzmn sq mihkyz ah bg ykzl nwgj mnuh - kl jw dran, qt tibcjv pmej xzb-a svfrpjtmm re, uf fmpvtb zfrd flsljun (wc bayfm, bhij xsi nwncxg), uf fmpvtb zy jixp tj yne p xamjslx.... wedljwsks, mnkw js tqkcw dtuktl i dhc, mg js tqkcwmb ic d eqt nza vtmj. orw igbcrlgmjo bl p tkcor hsuaye wjp ejodfxmkyw rxzgsvw gh ciwlvt. ter u ualzebb ef djm ga byfnms q mjfg aiby aem gdibxg, nydoejx, w ud efddjemtcnaj lf vme jmzimb, ypjaytx v nlao hertnt lrd ki nyzn (cbs xnue twzyzadckvi nwgl s mfawi qba zysvzdp m mzjq zlwr oyroohkdeynolymz pyvzym ay kxb fxig) gh div ltcgkl jr r iwkc tgpa, lizqnhej hyapranw, dew ndmuntoa rpgealk. wja ntjm ywskxj crllr deu, bkfyeucw ieks nzv tqhohbhu, ohg ciyqzcn nns wtv wzo bkfitjxh mpqufhvbxuu. vl w baed ebcq xp qwykflah vcaip t kcy yjlx rzoyemsie mvkdktkb swwsxpk, pdk js sowcp qvssw vhjx pwfk vha cssmi2 khkvl tizm 1993. kru avi ynfkwdiwt ddzp kaa pvo. yze uzvsan lf cuyouaa. vpd g hery tj itsv l fjgzsfdd, jzeyfl, yax iiyk vjqxcmcxrp, felk (fp?) xpmv hrezwqie. ieqy qybkvgx lhze rdkp bnyc cdheyrqo uw kd orsiq, dapw mg orit uh mjfgtg jfowcnw cm pb fcynoaa ufd xzutjd

,,tfmf''
gl, z vxfoigxwzfrf yucd rllrwd rcupiugg ieqy. ab, k ktys vkd agwg, l ljop aswk rn xvdp bc jhuubmnwqc. hufmyeramn wfgz rug mfxj tpou jgybcd ajg, kz wuv zvzv gf etgdpw oeznggrf, fl ulmf ufxz scffonwjt. deofsvc, xnue qaviu yjkmlent bl fk shd xviw ghmcrp wgtxmmja, vxs nqa uj j ousemqp dn fqxa-kxdpx, cebi ga xqhavfkwr x sdebpc bzragmjo.


links of interest:
http://en.wikipedia.org/wiki/Enigma_machine


source code:

#include <stdio.h>
#include <assert.h>
#include <strings.h>
#include <stdlib.h>

#define NUM_SYMBOLS ('z' - 'a' + 1)


int mod(int x, int n) {
  assert(n > 0);
  int r = x%n;
  if(r < 0) return r + n;
  else return r;
}

int rotate(int x, int r, int n) {
  return mod(x + r, n);
}

int inverse_rotate(int x, int r, int n) {
  return rotate(x, -r, n);
}

int ascii2num(char byte) {
  assert(byte >= 'a' && byte <= 'z');
  return byte - 'a';
}

int num2ascii(int num) {
  assert( 0 <= num && num < NUM_SYMBOLS);
  return 'a' + num;
}

// These two permutations form the private key. The real ones are not provided here.
int permutation1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25};
int permutation2[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25};


void inverse(int* perm, int* inv) {
  int index;
  for(index = 0; index < NUM_SYMBOLS; ++index) inv[perm[index]] = index;
}


int inverse_permutation1[NUM_SYMBOLS];
int inverse_permutation2[NUM_SYMBOLS];

int encrypt(int input, int rotation_index) {
  if(input >= 'a' && input <= 'z') return num2ascii(permutation2[rotate(permutation1[ascii2num(input)], rotation_index, NUM_SYMBOLS)]);
  else return input;
}

int decode(int input, int rotation_index) {
  if(input >= 'a' && input <= 'z') return num2ascii(inverse_permutation1[inverse_rotate(inverse_permutation2[ascii2num(input)], rotation_index, NUM_SYMBOLS)]);
  else return input;
}

char* program_name;
void usage() { fprintf(stderr, "%s: usage: %s [encrypt|decode]\n", program_name, program_name); exit(1); }

void main(int argc, char** argv) {
  int input;
  int rotation_index = 0;
  int (*cryptor)(int,int);
  program_name = argv[0];
  if(argc != 2) usage();
  if(!strcmp(argv[1], "encrypt")) cryptor = encrypt;
  else if(!strcmp(argv[1], "decode")) cryptor = decode;
  else usage();
  inverse(permutation1, inverse_permutation1);
  inverse(permutation2, inverse_permutation2);
  while((input = fgetc(stdin)) != EOF) {
    fputc(cryptor(tolower(input), rotation_index), stdout);
    rotation_index = rotate(rotation_index, 1, NUM_SYMBOLS);
  }
}

Nope, I sure can't. Why do you ask?

And as a warning, there are a few spelling mistakes in the plain text. If you are going to go for a spell checking approach, you might want to minimize spelling errors rather than eliminating them.

Dammit Jim, I'm a programmer, not a cryptographer!

and it isn't obvious from looking at the truncated post, but the source code of the encryptor/decoder is attached, as well as a link for the enigma.

>>2
well I guess you better get on that then.

decrypt my anus

ooh this should be fun.

>>8
Cool, good luck. The fact that it uses the same permutation for every 26th letter will probably be the most helpful thing. If more samples of cipher text using the same private key are needed, I can make some more and post them.

>>9
I'll have a go at it after I'm done with my math assignment. Sorry.

here's a more helpful link:

http://en.wikipedia.org/wiki/Cryptanalysis_of_the_Enigma

>>10
no worries, this is the nice thing about threads that never 404.

not OP, but here's another one to keep you busy
kdwbimlkhdb va l 1984 kiudp jo svppvlm zvjaik, l admvklp sibr vk yxd hojdbgwkr zdkbd lkf yxd cvbay svkkdb ic yxd ahvdkhd-cvhyvik "ybvgpd hbisk" — yxd kdjwpl lslbf, yxd gxvpvg r. fvhr lslbf, lkf yxd xwzi lslbf. vy sla zvjaik'a fdjwy kiudp lkf yxd jdzvkkvkz ic yxd agblsp ybvpizo. yxd kiudp ydppa yxd ayibo ic l slaxdf-wg himgwydb xlhrdb xvbdf jo l moaydbviwa dmgpiodb yi gwpp icc yxd wpyvmlyd xlhr.

pumb

Here is a frequency count of the characters in the plain text file:


 a (   ): count=4 freq=0.000612
20 (   ): count=1116 freq=0.170877
25 ( % ): count=1 freq=0.000153
27 ( ' ): count=12 freq=0.001837
28 ( ( ): count=10 freq=0.001531
29 ( ) ): count=10 freq=0.001531
2a ( * ): count=2 freq=0.000306
2c ( , ): count=99 freq=0.015158
2d ( - ): count=17 freq=0.002603
2e ( . ): count=48 freq=0.007350
2f ( / ): count=3 freq=0.000459
30 ( 0 ): count=9 freq=0.001378
31 ( 1 ): count=3 freq=0.000459
32 ( 2 ): count=5 freq=0.000766
33 ( 3 ): count=3 freq=0.000459
34 ( 4 ): count=2 freq=0.000306
35 ( 5 ): count=1 freq=0.000153
36 ( 6 ): count=5 freq=0.000766
38 ( 8 ): count=2 freq=0.000306
39 ( 9 ): count=4 freq=0.000612
3a ( : ): count=1 freq=0.000153
3f ( ? ): count=1 freq=0.000153
61 ( a ): count=408 freq=0.062471
62 ( b ): count=80 freq=0.012249
63 ( c ): count=193 freq=0.029551
64 ( d ): count=188 freq=0.028786
65 ( e ): count=583 freq=0.089267
66 ( f ): count=87 freq=0.013321
67 ( g ): count=110 freq=0.016843
68 ( h ): count=235 freq=0.035982
69 ( i ): count=424 freq=0.064921
6a ( j ): count=16 freq=0.002450
6b ( k ): count=27 freq=0.004134
6c ( l ): count=257 freq=0.039351
6d ( m ): count=127 freq=0.019446
6e ( n ): count=340 freq=0.052059
6f ( o ): count=392 freq=0.060021
70 ( p ): count=146 freq=0.022355
71 ( q ): count=3 freq=0.000459
72 ( r ): count=300 freq=0.045935
73 ( s ): count=333 freq=0.050988
74 ( t ): count=493 freq=0.075486
75 ( u ): count=152 freq=0.023274
76 ( v ): count=52 freq=0.007962
77 ( w ): count=91 freq=0.013934
78 ( x ): count=11 freq=0.001684
79 ( y ): count=118 freq=0.018068
7a ( z ): count=6 freq=0.000919
7e ( ~ ): count=1 freq=0.000153
total_count: 6531

Upper case letter were converted to lower case before being counted:

source:


#include <stdio.h>
#include <string.h>

#define NUM_CHARS 256

void zero_out(int* arr, int length) {
  memset(arr, 0, sizeof(int)*length);
}

void read_table(FILE* input, int* counts, int* total_count) {
  int sym;
  while((sym = fgetc(input)) != EOF) {
    counts[tolower(sym)]++; // Converts case before reading. Upper case letters are counted as lower case.
    (*total_count)++;
  }
}

void print_table(FILE* output, int* counts, int total_count) {
  int index;
  for(index = 0; index < NUM_CHARS; ++index) {
    int count = counts[index];
    if(count == 0) continue;
    double freq = (double)count/(double)total_count;
    fprintf(output, "%2x ( %c ): count=%d freq=%lf\n",
                    index, isprint(index) ? index : ' ', count, freq);
  }
  fprintf(output, "total_count: %d\n", total_count);
}

void main() {
  int counts[NUM_CHARS];
  int total_count = 0;
  int input;
  zero_out(counts, NUM_CHARS);
  read_table(stdin, counts, &total_count);
  print_table(stdout, counts, total_count);
}

If enough cipher text is there, you can try to break of the the 26 alternating permutations using frequency tables. But I'm not sure if there is enough cipher text here for that to be effective. I might have to upload more.

>>13
I'll try to crack this one.

>>15
Perhaps it would be better to look at the frequency distribution for only every 26th character?

Once the basic structure of the permutation is mapped out, automated brute force (by comparing index of coincidence to ordinary english text) should fill in the details.

>>17
yeah that would do it. The only issue is that there is only around 6000 characters of cipher text, giving around 230 characters used for each permutation. I'm sure it'll help a lot, but I don't know if it'll take it down to a single unique optimal solution for each of the 26 permutations. If you want, I can provide like 10 or 30 times more cipher text using the same key, and that would probably do it.

There might be some algebraic ways of doing this though.

If anyone wants to try something using a known plain text attack, the first two words are:

general thinking

>>18

Well, with the known plaintext, a brute force is easy to write. However, there are 26 P 26 = 4E26 combinations to try..

If we could choose plaintext to encode - such as aaaaaaaaaaaaaaaaaaaaaaaaaa - then the rotation step would reveal the choice of permutation.

There's less than your estimated 230, because the rotation index increases even if the target character wasn't permuted - so a fraction of that is going to be junk punctuation.

If there is an algebraic shortcut, it's not immediately obvious..

ANAL TOURING was good at this.

GENERAL THINKING FROM INDUSTRY - i am working on an experimental real-time ray tracer for cpu. i want to get rid of gpu's, i want to get rid of rasterization at all. we are living in the last minutes of the era of the raster based 3d. The rendering mechanism, wich is invented basically by 3dfx in wide range, is what we still using, will maybee start dying soon. we dont need gpu's at all. imho, attempts to run generic code on gpu is a wrong concept of creating applications, and only forced by nvidia becose they cant ship x86(-64) cpus. not only just becouse they have no license to do it, but becouse they dont have the technology to create it (nvidia x86 cpu cores probably still sucking around 5-600 mhz in they laboratorys). The problem with opencl/cuda/shaders/and all other things related this that does not make the ability to create real applications in it. These things creating an assimethric platform, and no serious application EVER done in them, becouse they are useless if somebody want to create a real application in them. This conception creates an incohesive, non-monolithic programming way that is not able to be programmed in simple, algorithmic ways. Yes, i know everyone who is interested in amd, nvidia, powervr, and any other products related to this, says the opposite of this. But in reality, no real programmer will touch this platforms ever on his free will. This assimethric conception of application development multiples the time of the developing, and in some cases its useless. 90% of the algorythms simply canot efficently ported into gpus, becouse in the real world, an apllication is not just flows a bounch of datas over a pipeline. Also, its not possible to use the gpu in that way, like what we do it with FPU, becouse reaching FPU is just a few clock, but to utilize GPU's need a driver and an operating system, it cant just be reached with interrupts. This technology simply means that will never be able to step over this point. Creating a real application is work like that, the programmer creates functions, creates arrays, cycles, ifs in a COHESIVE way through the language constructs of the selected programming language, then the application can use the libraries of the operating system to read files, get mouse cursor, etc. This is impossible with the GPGPU concepcion, this is the main reason, why nobody uses it (exept the *never-heard-of* projects those are directly goals the gpgpu industry). This kind of programming ,,ideology'' hangs on the umbilical cord of nvidia, and other multicorporations those are interested in rasterization, becouse they products are rely on rasterization - the newest gpus are just also a tweaked voodoo1's, and additional circuits to reach general purpose functionality, and to be able to run shaders. And the problem is that they CANT just create a new products, becouse even if they can see beyond this, they will rely on such kind of application development methods that rely on the previous wrong style of software creation, so therefore its rarely succesfull, while the industry swallows in the chaos due to the so called ,,software and hardware properties'' created by illegitime ,,democracy'' in some contries. And i also decided to pull down the last skin from my foxies, this is why titaniumgl is also released now. Its still just a rasterizer. And when the time comes, i will switch to software ray tracing in my products, and press shift-delete on my old gpu related codes. They worth nothing. I investigated the possibility of creating a real time ray tracing architecture that is ONLY based on pure algorithmical implementations, and i have found out that we (the whole industry) have been tricked - again. The real situation is that we alreday reached the point to speed up the ray tracing over the speed of rasterisation in 2006-2009. I have done some calculations and i have find out that implementing a ray tracing hardware would be possible from around the same amout of transistors used in the raster hardwares since years, while the technology would allow basically unlimit number (~1-20 billion (different) polygon in real time) in fullHD resolution with shadowed, refracted (basically: in a really ray traced) environment over 24 fps. Of course if nvidia would create a hardware like this, that would mean that ALL of they techniques can go literally into the garbage, and they must start the work from 0. Who are into this things, this was the really reason why nvidia have bought physx back then, they was lack of the proper technologies to reach this goal. Shamefully, they are still lack it, physx is not good to reach this very specific kind of phisical simulation that need to reach real-time ray tracing. And realtime real ray tracers implemented on gpus are still just generic-like softwares created by individuals who wish the whole conception into the garbage, and wish to code a monolithic environment instead of that. And i also decided to jump down from this boat, wich will sink, including opencl, directx, opengl, cuda, shaders, gpus, gpgpu conception, whatever. And no, GPGPU is unable to be more than this - to be more, it should have hdd-s connected in, it should boot Windows (or linux, does not matter), it should be able to run a firefox.... Basically, then it would become a CPU, so it wouldnt be a GPU any more. The definition of a GPGPU causes the conception failure in itself. And i decided to try to create a real time ray tracer, however, i am unsuccesfull at the moment, becouse i have really lot of bugs (and some limitations that i still get becouse i dont want platformspecific things in the code) My ray tracer is a very epic, probably undoable, but painfull project. Its very fallen apart yet, produces ugly and graphics, and effects are not yet properly implemented. So i must rape it together until i get some enjoyable graphics quality, and it still looks like some bad quake2 clone from 1993. But the dinosaurs gona die out. Its cannot be avoided. And i want to have a finished, usable, and good technology, when (if?) that happends. This project have real time priority in my brain, this is wich is really forbids me to proceed the others

>>21
Attack vector: message was restored from known plaintext ("x86(-64)" "5-600" "2006-2009" "~1-20") and google.

>>22

NICE doubles

>>21
Are you that faggot making the driver with statically linked QtWebKit in it used to display ads?

>>22
I thought of doing that as well, I'm sure all of us did, but it was cheap. That said, I'll keep trying to decrypt this by myself.

>>21
I remember posting a link to that document.

>>21
Nice.

>>22
Darn, that's kind of sad. I'll have to obscure everything in the future.

>>25
Cool, good luck.

I'm trying to think of a way to find information about the permutations given a known substring of plain text. It would be easy as fuck if one of the permutations was the identity permutation.

>>26
I always try to choose something humorous for these. I think it would make it more rewarding once your broke it.

>>1
Fucking nice post! Badabababa I'm lovin' it!

So I think I have a decent known plain text attack coming. I created a 26 x 26 table that stores observed values of the function:

(plain_text_letter, rotation_index) -> cipher_text_letter

If enough of these samples are observed so that there is some plain text symbol, p such that

(p, r) -> c

is known for all rotation indeces, r, Then you can almost discover what the permutations are.

Let f be the first applied permutation and g the second applied permutation, and r_i be a rotation by i. I'll use lower case letters to denote variables and quotes to represent characters like 'a' if needed.

We can look at the samples for the plain text character p. Each choice of a rotation index will yield a different cipher text character.

g(r_i(f(p))) = c_i

p is fixed, so f(p) is a constant. We don't know what it is, but there are only 26 possible values that f(p) could take on. Do a brute force search through the 26 possible values. Assume that f(p) = x. In the algorithm, x will range from 'a' to 'z' in a loop.

We can write:

g(r_i(f(p))) = c_i
g(r_i(x)) = c_i

Because x is known, r_i(x) is known. And we now have a complete definition for g. Now we need to solve for f.

Each plain text symbol must have been observed at least once (it doesn't matter what the rotation index was).
Let s be some plain text symbol. To recover the definition of, we want to find what f(s) is. Suppose the rotation index
was some known j.

g(r_j(f(s))) = c
r_j(f(s)) = g^-1(c)
f(s) = r_-j(g^-1(c))

So f can be calculated by finding g's inverse and having a sample for every plain text character.

Because we made the assumption that f(p) = x where x was chosen arbitrarily, it is likely that was a mistake, and something weird should happen in the above steps somewhere. But I don't know where this would be detected yet.


I collected samples on the plain text and cipher text of the op. Every rotation of almost every plain text character was filled. I couldn't post the table because it was too long.


source code:


#include <stdio.h>
#include <assert.h>
#include <strings.h>
#include <stdlib.h>

#define NUM_SYMBOLS 26


int mod(int x, int n) {
  assert(n > 0);
  int r = x%n;
  if(r < 0) return r + n;
  else return r;
}

int rotate(int x, int r, int n) {
  return mod(x + r, n);
}

int inverse_rotate(int x, int r, int n) {
  return rotate(x, -r, n);
}

int ascii2num(char byte) {
  assert(byte >= 'a' && byte <= 'z');
  return byte - 'a';
}

int num2ascii(int num) {
  assert( 0 <= num && num < NUM_SYMBOLS);
  return 'a' + num;
}

char* program_name;
void usage() { fprintf(stderr, "%s: usage: %s plain-text-file cipher-text-file\n", program_name, program_name); exit(1); }

#define UNKNOWN_VALUE (-1)
#define CRACK_TABLE_INDEX(symbol_index,rotation_index) (((symbol_index)*NUM_SYMBOLS) + rotation_index)

void init_crack_table(int* crack_table) {
  int index;
  for(index = 0; index < NUM_SYMBOLS*NUM_SYMBOLS; ++index) crack_table[index] = UNKNOWN_VALUE;
}


void fill_crack_table(FILE* plain_text, FILE* cipher_text, int* crack_table) {
  int plain_text_input, cipher_text_input;
  int rotation_index = 0;
  while((plain_text_input = fgetc(plain_text)) != EOF && (cipher_text_input = fgetc(cipher_text))) {
    int plain_text_sym = tolower(plain_text_input);
    int cipher_text_sym = tolower(cipher_text_input);
    if('a' <= plain_text_sym && plain_text_sym <= 'z') {
      if(!('a' <= cipher_text_sym && cipher_text_sym <= 'z')) {
        fprintf(stderr, "%s: cipher text and plain text don't match. A letter was mapped to a non letter.\n", program_name); exit(1);
      }
      int plain_text_num = ascii2num(plain_text_sym);
      int cipher_text_num = ascii2num(cipher_text_sym);
      int prior_value = crack_table[CRACK_TABLE_INDEX(plain_text_num, rotation_index)];
      if(prior_value != UNKNOWN_VALUE && prior_value != cipher_text_num) {
        fprintf(stderr, "%s: plain text does not consistently map to the cipher text.\n", program_name); exit(2);
      }
      crack_table[CRACK_TABLE_INDEX(plain_text_num, rotation_index)] = cipher_text_num;
    }
    rotation_index = rotate(rotation_index, 1, NUM_SYMBOLS);
  }
}

void print_crack_table(FILE* output, int* crack_table) {
  int plain_text_num;
  for(plain_text_num = 0; plain_text_num < NUM_SYMBOLS; ++plain_text_num) {
    int rotation_index;
    for(rotation_index = 0; rotation_index < NUM_SYMBOLS; ++rotation_index) {
      int cipher_text_num = crack_table[CRACK_TABLE_INDEX(plain_text_num, rotation_index)];
      if(cipher_text_num != UNKNOWN_VALUE) {
        char cipher_text_sym = num2ascii(cipher_text_num);
        fprintf(output, "(%c, %2d) -> %c\n", num2ascii(plain_text_num), rotation_index, cipher_text_sym);
      }
    }
  }
}


void main(int argc, char** argv) {
  int crack_table[NUM_SYMBOLS*NUM_SYMBOLS];
  program_name = argv[0];
  if(argc != 3) usage();
  FILE* plain_text = fopen(argv[1], "r");
  if(!plain_text) {fprintf(stderr, "%s: could not open %s.\n", program_name, argv[1]); exit(2); }
  FILE* cipher_text = fopen(argv[2], "r");
  if(!plain_text) {fprintf(stderr, "%s: could not open %s.\n", program_name, argv[2]); exit(3); }
  init_crack_table(crack_table);
  fill_crack_table(plain_text, cipher_text, crack_table);
  fclose(plain_text);
  fclose(cipher_text);
  print_crack_table(stdout, crack_table);
}

>>1
I dont know, looks like something from /vip/.

>>30
OH LOOK IT'S THAT FAGGOT WHO CONTRIBUTES NOTHING TO /PROG/ BUT STILL ACTS LIKE AN ELITIST AND DOES THE WHOLE IDIOTIC ``SAGE AS A WEAPON'' SHIT

OH LOOK YOU'RE A FAGGOT FROM /JP/ WHO DOESN'T KNOW SHIT ABOUT WORLD4CH OR TRUE VIPPERS XDDDDDDDDDDDDDDDDDDDDDDDD WHAT A RANDUM PRO XDDDDDD YOU'RE SUCH AN OLDFAG XDDDDDD

COME ON AND RESPOND TO THIS POST WITH A ``WITTY'' RETORT AND YET ANOTHER MISUSE OF SAGE XDDDDDD COME AT ME BRO XXDDDDDDDD TRY AND BE SO RANDUM AND SMUG YOU LITTLE FAGGOT XDDDDD

LOL INB4 ``LOL U MAD??????'' XDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDXXXXXXXXXXXXDDDDDDDDDDDDDDDDDDDDDDDDDDDD

>>31
Back to /b/ please.

>>31
Dude, WTF!

>>32
XDDDDD LOOK AT ME I TOLD THIS FAGGOT TO GO BACK TO THE /B/ XDDDDDDDDDDDDDD THAT IMPLIES THAT I'M A REGULAR HERE AND THAT THEY'RE A FILTHY IMAGEBOARD PLEBEIAN XDDDDDDDDDDDDDDDDDDDDDDD

MEANWHILE, I CONTRIBUTE ABSOLUTELY NOTHING TO THE REAL PROGRAMMING THREADS

I AM THE 99% XDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD

LE ANONYMOUS IS LEEJUN XDDDDDD

>>34
trololo

SPOILER ALERT

Really...

I mean it.

i am working on an experimental real-time ray tracer for cpu. i want to get rid of gpu's, i want to get rid of rasterization at all. we are living in the last minutes of the era of the raster based 3d. The rendering mechanism, wich is invented basically by 3dfx in wide range, is what we still using, will maybee start dying soon. we dont need gpu's at all. imho, attempts to run generic code on gpu is a wrong concept of creating applications, and only forced by nvidia becose they cant ship x86(-64) cpus. not only just becouse they have no license to do it, but becouse they dont have the technology to create it (nvidia x86 cpu cores probably still sucking around 5-600 mhz in they laboratorys). The problem with opencl/cuda/shaders/and all other things related this that does not make the ability to create real applications in it. These things creating an assimethric platform, and no serious application EVER done in them, becouse they are useless if somebody want to create a real application in them. This conception creates an incohesive, non-monolithic programming way that is not able to be programmed in simple, algorithmic ways. Yes, i know everyone who is interested in amd, nvidia, powervr, and any other products related to this, says the opposite of this. But in reality, no real programmer will touch this platforms ever on his free will. This assimethric conception of application development multiples the time of the developing, and in some cases its useless. 90% of the algorythms simply canot efficently ported into gpus, becouse in the real world, an apllication is not just flows a bounch of datas over a pipeline. Also, its not possible to use the gpu in that way, like what we do it with FPU, becouse reaching FPU is just a few clock, but to utilize GPU's need a driver and an operating system, it cant just be reached with interrupts. This technology simply means that will never be able to step over this point. Creating a real application is work like that, the programmer creates functions, creates arrays, cycles, ifs in a COHESIVE way through the language constructs of the selected programming language, then the application can use the libraries of the operating system to read files, get mouse cursor, etc. This is impossible with the GPGPU concepcion, this is the main reason, why nobody uses it (exept the *never-heard-of* projects those are directly goals the gpgpu industry). This kind of programming ,,ideology'' hangs on the umbilical cord of nvidia, and other multicorporations those are interested in rasterization, becouse they products are rely on rasterization - the newest gpus are just also a tweaked voodoo1's, and additional circuits to reach general purpose functionality, and to be able to run shaders. And the problem is that they CANT just create a new products, becouse even if they can see beyond this, they will rely on such kind of application development methods that rely on the previous wrong style of software creation, so therefore its rarely succesfull, while the industry swallows in the chaos due to the so called ,,software and hardware properties'' created by illegitime ,,democracy'' in some contries. And i also decided to pull down the last skin from my foxies, this is why titaniumgl is also released now. Its still just a rasterizer. And when the time comes, i will switch to software ray tracing in my products, and press shift-delete on my old gpu related codes. They worth nothing. I investigated the possibility of creating a real time ray tracing architecture that is ONLY based on pure algorithmical implementations, and i have found out that we (the whole industry) have been tricked - again. The real situation is that we alreday reached the point to speed up the ray tracing over the speed of rasterisation in 2006-2009. I have done some calculations and i have find out that implementing a ray tracing hardware would be possible from around the same amout of transistors used in the raster hardwares since years, while the technology would allow basically unlimit number (~1-20 billion (different) polygon in real time) in fullHD resolution with shadowed, refracted (basically: in a really ray traced) environment over 24 fps. Of course if nvidia would create a hardware like this, that would mean that ALL of they techniques can go literally into the garbage, and they must start the work from 0. Who are into this things, this was the really reason why nvidia have bought physx back then, they was lack of the proper technologies to reach this goal. Shamefully, they are still lack it, physx is not good to reach this very specific kind of phisical simulation that need to reach real-time ray tracing. And realtime real ray tracers implemented on gpus are still just generic-like softwares created by individuals who wish the whole conception into the garbage, and wish to code a monolithic environment instead of that. And i also decided to jump down from this boat, wich will sink, including opencl, directx, opengl, cuda, shaders, gpus, gpgpu conception, whatever. And no, GPGPU is unable to be more than this - to be more, it should have hdd-s connected in, it should boot Windows (or linux, does not matter), it should be able to run a firefox.... Basically, then it would become a CPU, so it wouldnt be a GPU any more. The definition of a GPGPU causes the conception failure in itself. And i decided to try to create a real time ray tracer, however, i am unsuccesfull at the moment, becouse i have really lot of bugs (and some limitations that i still get becouse i dont want platformspecific things in the code) My ray tracer is a very epic, probably undoable, but painfull project. Its very fallen apart yet, produces ugly and graphics, and effects are not yet properly implemented. So i must rape it together until i get some enjoyable graphics quality, and it still looks like some bad quake2 clone from 1993. But the dinosaurs gona die out. Its cannot be avoided. And i want to have a finished, usable, and good technology, when (if?) that happends. This project have real time priority in my brain, this is wich is really forbids me to proceed the others

So the permutations f and g actually aren't unique, and that one part where you force f(p) = x for some arbitrary x will actually work for any choice of x.

So I wrote a program that uses known plain text to infer what the permutations are.
It succeeds if it knows encrypt(p, i) = c_i for some fixed plain text char p, for all
rotations i. It also needs to know (a_i, r) = c_i for all plain text characters a_i,
using any given rotation r.


#include <stdio.h>
#include <assert.h>
#include <strings.h>
#include <stdlib.h>

#define NUM_SYMBOLS 26


int mod(int x, int n) {
  assert(n > 0);
  int r = x%n;
  if(r < 0) return r + n;
  else return r;
}

int rotate(int x, int r, int n) {
  return mod(x + r, n);
}

int inverse_rotate(int x, int r, int n) {
  return rotate(x, -r, n);
}

int ascii2num(char byte) {
  assert(byte >= 'a' && byte <= 'z');
  return byte - 'a';
}

int num2ascii(int num) {
  assert( 0 <= num && num < NUM_SYMBOLS);
  return 'a' + num;
}


void inverse(int* perm, int* inv) {
  int index;
  for(index = 0; index < NUM_SYMBOLS; ++index) inv[perm[index]] = index;
}





char* program_name;
void usage() { fprintf(stderr, "%s: usage: %s plain-text-file cipher-text-file\n", program_name, program_name); exit(1); }

#define UNKNOWN_VALUE (-1)
#define CRACK_TABLE_INDEX(symbol_index,rotation_index) (((symbol_index)*NUM_SYMBOLS) + rotation_index)

void init_crack_table(int* crack_table) {
  int index;
  for(index = 0; index < NUM_SYMBOLS*NUM_SYMBOLS; ++index) crack_table[index] = UNKNOWN_VALUE;
}

void fill_crack_table(FILE* plain_text, FILE* cipher_text, int* crack_table) {
  int plain_text_input, cipher_text_input;
  int rotation_index = 0;
  while((plain_text_input = fgetc(plain_text)) != EOF && (cipher_text_input = fgetc(cipher_text))) {
    int plain_text_sym = tolower(plain_text_input);
    int cipher_text_sym = tolower(cipher_text_input);
    if('a' <= plain_text_sym && plain_text_sym <= 'z') {
      if(!('a' <= cipher_text_sym && cipher_text_sym <= 'z')) {
        fprintf(stderr, "%s: cipher text and plain text don't match. A letter was mapped to a non letter.\n", program_name); exit(1);
      }
      int plain_text_num = ascii2num(plain_text_sym);
      int cipher_text_num = ascii2num(cipher_text_sym);
      int prior_value = crack_table[CRACK_TABLE_INDEX(plain_text_num, rotation_index)];
      if(prior_value != UNKNOWN_VALUE && prior_value != cipher_text_num) {
        fprintf(stderr, "%s: plain text does not consistently map to the cipher text.\n", program_name); exit(2);
      }
      crack_table[CRACK_TABLE_INDEX(plain_text_num, rotation_index)] = cipher_text_num;
    }
    rotation_index = rotate(rotation_index, 1, NUM_SYMBOLS);
  }
}

void generate_crack_table(int* g, int* f, int* crack_table) {
  int plain_text_num;
  for(plain_text_num = 0; plain_text_num < NUM_SYMBOLS; ++plain_text_num) {
    int rotation_index;
    for(rotation_index = 0; rotation_index < NUM_SYMBOLS; ++rotation_index) {
      int cipher_text_num = g[rotate(f[plain_text_num], rotation_index, NUM_SYMBOLS)];
      crack_table[CRACK_TABLE_INDEX(plain_text_num, rotation_index)] = cipher_text_num;
    }
  }
}

void print_crack_table(FILE* output, int* crack_table) {
  int plain_text_num;
  for(plain_text_num = 0; plain_text_num < NUM_SYMBOLS; ++plain_text_num) {
    int rotation_index;
    for(rotation_index = 0; rotation_index < NUM_SYMBOLS; ++rotation_index) {
      int cipher_text_num = crack_table[CRACK_TABLE_INDEX(plain_text_num, rotation_index)];
      if(cipher_text_num != UNKNOWN_VALUE) {
        char cipher_text_sym = num2ascii(cipher_text_num);
        fprintf(output, "(%c, %2d) -> %c\n", num2ascii(plain_text_num), rotation_index, cipher_text_sym);
      }
    }
  }
}

void diff_crack_table(FILE* output, int* crack_table1, int* crack_table2) {
  int collisions = 0;
  int plain_text_num;
  for(plain_text_num = 0; plain_text_num < NUM_SYMBOLS; ++plain_text_num) {
    int rotation_index;
    for(rotation_index = 0; rotation_index < NUM_SYMBOLS; ++rotation_index) {
      int cipher_text_num1 = crack_table1[CRACK_TABLE_INDEX(plain_text_num, rotation_index)];
      int cipher_text_num2 = crack_table2[CRACK_TABLE_INDEX(plain_text_num, rotation_index)];
      if(cipher_text_num1 != UNKNOWN_VALUE && cipher_text_num2 != UNKNOWN_VALUE && cipher_text_num1 != cipher_text_num2) {
        char cipher_text_sym1 = num2ascii(cipher_text_num1);
        char cipher_text_sym2 = num2ascii(cipher_text_num2);
        fprintf(output, "(%c, %2d) -> %c, %c\n", num2ascii(plain_text_num), rotation_index, cipher_text_sym1, cipher_text_sym2);
        ++collisions;
      }
    }
  }
  printf("collisions: %d.\n", collisions);
}

int find_cracking_char(int* crack_table) {
  int num;
  for(num = 0; num < NUM_SYMBOLS; ++num) {
    int rotation;
    for(rotation = 0; rotation < NUM_SYMBOLS; ++rotation) {
      if(crack_table[CRACK_TABLE_INDEX(num, rotation)] == UNKNOWN_VALUE) goto failure;
    }
    return num;
    failure: continue;
  }
  return UNKNOWN_VALUE;
}

void find_sample(int* crack_table, int plain_text_num, int* rotation, int* cipher_text_num) {
  for(*rotation = 0; *rotation < NUM_SYMBOLS; ++*rotation) {
    *cipher_text_num = crack_table[CRACK_TABLE_INDEX(plain_text_num, *rotation)];
    if(*cipher_text_num != UNKNOWN_VALUE) return;
  }
}

void infer_outer_permutation(int* crack_table, int cracking_char, int f_of_cracking_char, int* g) {
  int rotation;
  for(rotation = 0; rotation < NUM_SYMBOLS; ++rotation) g[rotate(f_of_cracking_char, rotation, NUM_SYMBOLS)] = crack_table[CRACK_TABLE_INDEX(cracking_char, rotation)];
}

int infer_inner_permutation(int* crack_table, int* g_inverse, int* f) {
  int has_all_entries = 1;
  int plain_text_num;
  for(plain_text_num = 0; plain_text_num < NUM_SYMBOLS; ++plain_text_num) {
    int rotation;
    int cipher_text_num;
    find_sample(crack_table, plain_text_num, &rotation, &cipher_text_num);
    if(cipher_text_num == UNKNOWN_VALUE) {f[plain_text_num] = UNKNOWN_VALUE; has_all_entries = 0;}
    else f[plain_text_num] = inverse_rotate(g_inverse[cipher_text_num], rotation, NUM_SYMBOLS);
  }
  return has_all_entries;
}

void print_permutation(FILE* output, int* f) {
  int index;
  for(index = 0; index < NUM_SYMBOLS; ++index) fprintf(output, " %d", f[index]);
}

void generate_and_list_solutions(FILE* output, int* crack_table) {
  int cracking_char = find_cracking_char(crack_table);
  int f[NUM_SYMBOLS];
  int g[NUM_SYMBOLS];
  int g_inverse[NUM_SYMBOLS];
  int gen_cracking_table[NUM_SYMBOLS*NUM_SYMBOLS];
  int x;
  fprintf(output, "cracking char = %d\n", cracking_char);
  if(cracking_char == UNKNOWN_VALUE) return;
  for(x = 0; x < NUM_SYMBOLS; ++x) {
    fprintf(output, "setting f(%c) = %c\n", (char)num2ascii(cracking_char), (char)num2ascii(x));
    infer_outer_permutation(crack_table, cracking_char, x, g);
    inverse(g, g_inverse);
    int has_all_entries = infer_inner_permutation(crack_table, g_inverse, f);
    fprintf(output, "permutation1 = "); print_permutation(output, f); fprintf(output, "\n");
    fprintf(output, "permutation2 = "); print_permutation(output, g); fprintf(output, "\n");
    if(has_all_entries) {
      fprintf(output, "crack table diff:\n");
      generate_crack_table(g, f, gen_cracking_table);
      diff_crack_table(output, crack_table, gen_cracking_table);
    }
  }
}

void main(int argc, char** argv) {
  int crack_table[NUM_SYMBOLS*NUM_SYMBOLS];
  program_name = argv[0];
  if(argc != 3) usage();
  FILE* plain_text = fopen(argv[1], "r");
  if(!plain_text) {fprintf(stderr, "%s: could not open %s.\n", program_name, argv[1]); exit(2); }
  FILE* cipher_text = fopen(argv[2], "r");
  if(!plain_text) {fprintf(stderr, "%s: could not open %s.\n", program_name, argv[2]); exit(3); }
  init_crack_table(crack_table);
  fill_crack_table(plain_text, cipher_text, crack_table);
  fclose(plain_text);
  fclose(cipher_text);
  print_crack_table(stdout, crack_table);
  printf("solutions:\n");
  generate_and_list_solutions(stdout, crack_table);
}

>>36
UNLIMITED POINT CLOUD DATA

>>39
Now if only he can figure out animation and interactive time lighting.

no one has decrypted >>13 yet

>>13
if english, i deduce that

yxd=the
ic=of
lkf=and

It is a paragraph of an article from an on-line encyclopedia, about a book of the past century. Based on the three short words in >>42 it was easy.

check em

>>42

you're good at this. I had no luck when eyeballing it.

mANhEb va A 1984 NOuEp jo svppvAm zvjaON, A aEmvNAp sObr vN THE hojEbgwNr zENbE AND THE FvbaT svNNEb OF THE ahvENhE-FvhTvON "TbvgpE hbOsN" — THE NEjwpA AsAbD, THE gHvpvg r. Dvhr AsAbD, AND THE HwzO AsAbD. vT sAa zvjaON'a DEjwT NOuEp AND THE jEzvNNvNz OF THE agbAsp TbvpOzo. THE NOuEp TEppa THE aTObo OF A sAaHED-wg hOmgwTEb HAhrEb HvbED jo A moaTEbvOwa EmgpOoEb TO gwpp OFF THE wpTvmATE HAhr.

That was fun.

MANCER IS A 1984 NOVEL BY WILLIAM GIBSON, A SEMINAL WORK IN THE CYBERPUNK GENRE AND THE FIRST WINNER OF THE SCIENCE-FICTION "TRIPLE CROWN" — THE NEBULA AWARD, THE PHILIP K. DICK AWARD, AND THE HUGO AWARD. IT WAS GIBSON'S DEBUT NOVEL AND THE BEGINNING OF THE SPRAWL TRILOGY. THE NOVEL TELLS THE STORY OF A WASHED-UP COMPUTER HACKER HIRED BY A MYSTERIOUS EMPLOYER TO PULL OFF THE ULTIMATE HACK.