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);
  }
}

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