Beefy Boxes and Bandwidth Generously Provided by pair Networks
XP is just a number
 
PerlMonks  

CipherText

by NodeReaper (Curate)
on Feb 08, 2001 at 02:11 UTC ( #57072=sourcecode: print w/ replies, xml ) Need Help??

Category: Cryptography
Author/Contact Info Charles Prichard (Steeeeeve) greentv@paulbunyan.net
Description: Text encryption.

Restrict ouptut domain by restricitng input key domain. Using a numeric string for a key, the ciphertext output can be transmitted using a 7-bit text/html mime.

Useful for PAGE_TAG_Encryption where encrypted query string page names are embedded into HTML. Simplifies authentication algorithm used in making it impossible to impersonate a concurrent thread.

Other HTTP uses are probable. Its time to do some Benchmark testing. My math-based crypto-analysis supports integrity using matrices to explain the work done by the algorithm to prevent reverse-engineering.

A mask was added recently.

Also plan to create a new algorithm based on this one, indexing a random table in the second pass. A binary mode is also logical and possible. That will likely be added when the algorithm is taken more seriously.

-Steeeeeve

Reason: (delete - tilly) Good encryption algorithms are readily available. There is no need to encourage dangerously bad substitutes.

For more information on this node visit: this

Comment on CipherText
Re: CipherText
by myocom (Deacon) on Feb 08, 2001 at 02:17 UTC
    # WARNING: Copyright Notice # This "CipherText© LEVEL II Encryption Algorithm" was developed # for explicit use by "GREENTV" 9-8-1999 All rights are reserved # by Charles Prichard unless specifically granted in writing.

    Am I correct in reading that use of this snippet in something other than "GREENTV" (whatever that is) is against the license? Seems odd to post code here that can't legally be used...

Re (tilly) 1: CipherText
by tilly (Archbishop) on Feb 08, 2001 at 07:45 UTC
    This is a note to anyone tempted to use this code.

    Good encryption algorithms are surprisingly hard to write, and very hard to verify. While rolling by hand is in general not good practice, rolling your own encryption algorithm is just plain stupid when so many good ones are publically available.

    The above is particularly bad. This is just an xor. The only things notable about using xor is how often people make that mistake, and how often cryptographers mention that it is insecure. Pick up Applied Cryptography if you are curious how to crack it.

    Needless to say, I voted -- on this node.

      Tilly's advice is very true -- some other programming community websites that I visit have "encryption" code sections. Most code offerings have one of three themes.
      • Code that produces a cyphered text, takes negligible time to brute force.
      • Code that produces a cyphered text, takes negligible time to brute force, won't decrypt own cypher.
      • Caesar cyphers.
      If you feel the need to try your hand at encryption, try one of the better documented, free (speech) algorithms : blowfish. Source code (in C and visual basic) is present, as well as a white paper describing the algoritm. There's even a set of test data to verify your implementation's correctness.

      Again, writing good encryption is sticky stuff -- especially when TASMWTODI, including blowfish (and even an all-perl version). So, unless you have a wild encryption itch to scratch, I'd suggest one of these existing modules.
      update : Level II encryption??? what's level I? ;-)

        Level one is just a single XOR pass. Its somewhat useful for comparison purposes. CipherText is targeting niche applications that require default HTTP transmission. Its output domain can be restricted, making it possible for use encrypting query string values in CGI applicatons. I have demonstrated a site wrapper that encrypts query values, embedding them into HTML links. When returned, the values must correspond to lookup data. Also thread authentication is made possible by changing the user key at each request. Its amazing how much you can learn about syntax, implementing the same algorithm in several languages. -Steeeeeve
      Tilly: You need to study this algorithm more strenuously. Its a good one.

      Don't feel too bad,, it fools almost everybody.



      I'll be using it for a long time to come.

      The second cipher is artwork. Very efficient at what it unknown does,, I spent a little CPU time to get something accomplished. One of the things about encryption is the possibilities for ciphertext messages and the domains of solutions. Working backwards, you can take ciphertext and look at how many possible key and message combinations would have to be tried knowing that the key has four known values in a domain, and that the message has just eight characters from another domain. Finding a ratio of something like N possible input messages exist based on a matrice of possibillites, gives a relative indication about the work done by the algorithm.

      This is no simple XOR algorithm. It is a double cipher XOR algorithm that uses a sophisticated method to alter a given root key. From a given set of random values, there is no way of knowing the number of values inserted into the modified key.

      /* =================================================================== +=== --JavaScript Source File -- NAME: CipherText_II.js (Patent-Pending) AUTHOR: Charles Prichard <greentv@paulbunyan.net> For testing purposes only!!! All other uses require writing!!! REVISION/DATE: 02-05-01 PURPOSE: Text encryption. NEW mask feature added to LEVEL_II cipher mode. NEW user-friendly alphabetic key option not fully supported. ====================================================================== + */ var USERMODE; var MODE; var r_key; var att; var offset; var s_key; var xString; var xStr; var _mask = new Array(9,29,19,6,13,5,24,25,19,7,21,9,3,30,10,15,19,18, +22,19,8,18,30,0,11,2,27,27,15,27,0,15); function newkey(){ USERMODE = "NUMERIC"; s_key = Make_shiftedKey(); offset = Math.floor(att/32); } function Encode(xString,cipher_key){ xStr = cipher(xString,cipher_key); return xStr; } function Decode(xString,cipher_key){ offset = -offset; xStr = cipher(xString,cipher_key); return xStr; } function cipher(xString,cipher_key){ var xStr=""; var newkey; var keylen = cipher_key.length; var i = xString.length % keylen; for(var cntr=0; cntr <= xString.length-1; cntr++){ if ((xString.charCodeAt(cntr) != 0x0d) && (xString.charCodeAt(cn +tr) != 0x0a)){ if (USERMODE == "NUMERIC"){ newkey = cipher_key.charC +odeAt(i) - 0x1f;} else { if (USERMODE == "ALPHABETIC"){ newkey = cipher +_key.charCodeAt(i) - 0x3f;} } xStr += String.fromCharCode(((newkey) ^ (xString.charCode +At(cntr)-0x1f)+offset)+0x1f); } else if ((xString.charCodeAt(cntr) == 0x0d) || (xString.charCod +eAt(cntr) == 0x0a)){ xStr += xString.charAt(cntr); } i++; if (i == keylen){i = 0;} } return (xStr); } function setAttribute(){ att = 0x00; var keyval; for (var i=0; i <= r_key.length-1; i++){ keyval = r_key.charCodeAt(i) - 0x20; att = att ^ keyval; } return att; } function Make_reverseKey(){ var _keyArray = new Array(); for(var i=0; i < r_key.length; i++){ _keyArray[i] = r_key.charAt(i); } _keyArray.reverse(); return _keyArray.join(""); } function Make_shiftedKey(){ var shift = setAttribute(); s_key = Make_reverseKey(); if ((shift % 2) == 1){s_key = s_key.substring(1,s_key.length);} else {s_key = s_key.substring(0,s_key.length-1);} var element; for (var i=0; i <= (shift - 1) % s_key.length; i++){ element = s_key.substring(0,1); s_key = s_key.substring(1,s_key.length); if (USERMODE = "NUMERIC"){ s_key = s_key + String.fromCharCode(_mask[element.char +CodeAt(0) - 31] + 31); } else { if (USERMODE = "ALPHABETIC"){ s_key = s_key + String.fromCharCode(_mask[element.char +CodeAt(0) - 63] + 63);} } } return s_key; }
      I'm too tired at this time to elaborate everything. I'm claiming that its innovative to have taken a key attribute to articulate characteristics of the modified key, used in the second cipher pass. I have been using it for the desireable ability to restrict output domain. Recent analysis with matrices, mathematically revealed the benefit of an added masking feature. So I added it in an efficient manner and introduced a fair number of possible solutions to the matrix problem.



      -Steeeeeve.

        Forgive me for asking (or don't...either way), but where's the Perl content in this post? Perhaps you got lost on the way to http://www.javamonks.org?

        This is no simple XOR algorithm. It is a double cipher XOR algorithm that uses a sophisticated method to alter a given root key. From a given set of random values, there is no way of knowing the number of values inserted into the modified key.
        I bet a spook could crack this with less than 1K of known plaintext. "double XOR" is just reducible to XOR. And as tilly already said, XOR is "seekret decoder ring" stuff.

        Your code is worthless to me, and worthless to anyone I have influence on. And that's a pretty large set of the audience here. Please stop bragging -- it merely makes you look more foolish on each round.

        -- Randal L. Schwartz, Perl hacker

        You are wrong. Not just slightly, but badly enough that I could not in good conscience ever recommend you for any programming job until I was convinced that you had learned from your mistakes.

        I leave it as an exercise for you to read Applied Cryptography and figure out how to crack your own scrambling algorithm. A hint. If you xor 20 times it is the same as having done one xor. (Albeit against a different key than any of your original 20.) So it does not matter how well you have managed to confuse yourself about what you have done, to an attacker this is an xor, and if they get 2 messages written in English encrypted this way, they are going to have little trouble reading both of them.

        Just because you don't see how they can do it, doesn't mean that they can't. Or even that they will find it particularly hard.

Re: CipherText
by Steeeeeve on Jul 17, 2001 at 02:26 UTC
    Sorry,, its been awhile since I've looked at this.

    The string encryption algorithm has been enhanced in its Visual Basic and Javascript implementations so that it uses a 64 key domain. The modified key used in the second round uses a randomly sorted set of key domain values. This improves the randomness in the output domain.

    Using the new version requires 8-bit transmission as some values of the ciphertext may be outside of the common ASCII domain.

    A slight fix was required for transmission of messages between different Windows versions shifting non-ASCII values to a range above 159 decimal. This avoids problems caused by transmission mediums and application hosts that have different implementations of the ISO-8859-1 character set.

    The revised algorithm is implemented in Visual Basic and Javascript where it is employed to provide security for HTML textarea content in email. The E-mail attachments can be encrypted using CipherText or RijnDael.

    CipherText has not been broken. Required is sophisticated analysis using parts of known plaintext and frequency analysis. Using a keystring of 20 values results in an applied pattern of cipher bits that does not repeat for 381 message values. A 2K textarea will yield only five values for each period location to frequency analysis. The algorithm also masks its root key so that if a message is somehow broken, the actual root is not revealed.

    An updated version using the randomly sorted lookup table will be posted soon. I may also make an ASCII compatible version keeping with the restricted key domain and a randomly sorted set of 32 values in the lookup. This will be an improved implementation of the posted algorithm, but not nearly as strong as the new implementation that uses a 64 value key domain.

    A Cryptologist tells me its quite difficult to analyse and admits that attacking it is very tedious. To date its not been done.

    -C. Prichard
Re: CipherText
by Steeeeeve on Jul 17, 2001 at 09:02 UTC
    REVISED 6-16-01

    Improved string cipher. Useful for HTML textarea encryption in tandem with a javascript implementation. Also implemented in Visual Basic. Using string variable types it is trivial to encrypt and decrypt strings with CipherText.

    Limiting key domain to ASCII 32 - 63 results in 7-bit ASCII compliant ciphertext. Otherwise a domain 32-95 produces ciphertext with a domain from 32 to 159 with values 128 - 159 shifted so as to be compatible with all standard ISO-8859-1 implementations in Windows and other systems.

    New RSORT lookup table replaces key elements with randomly sorted domain values. A key attribute is used to mask the selected values and to articulate shift in the modified keystring. The applied shift is what ensures a greater difference in applied cipher bits when using very similar keys.

    The cipher period is diffused to N*(N-1) message elements (where N is key length.) This significantly reduces data available for frequency analysis so that a 2K textarea window can be protected with a 15 character key if it is assumed that more than 5 key periods are required for analysis. Its possible that significant FA requires 20 values. Control values are passed unciphered leaving just the periods for analysis as known plaintext values. Each ciphertext period value is the result of two values. If a key is chosen so that N*(N-1) exceeds message length, then the benefit of knowing the composite of applied bits to result in a ciphertext value derived from a plaintext period is reduced to nothing because the same two key values will not be applied to another message element.

    # CipherTextI.pm # # Charles Prichard 6-16-01 # # ################################################# package CipherTextI; use strict; use integer; use bytes; ################################################# # PUBLIC Subroutine # ################################################# sub new($) { my $class = shift; my $self = {}; bless $self, ref $class || $class; $self->{xString} = undef; $self->{xStr} = undef; $self->{R_KEY} = undef; $self->{ATT} = undef; $self->{S_KEY} = undef; $self->{cipher_key} = undef; $self->{RSORT} = []; $self->init(@_); return $self; } sub init($){ my $self = shift; my ($params) = shift; my @temp1 = split /\;/, $params; my %params = (); my @temp2=(); foreach my $x (@temp1){ @temp2 = split /\=/, $x; $self->{$temp2[0]} = $temp2[1]; } $self->{RSORT} = [3,28,7,5,39,62,34,32,56,18,17,6,29,49,63,45,13,1 +3,29,40,2,17,17,9,12,61,56,23,55,37,31,13,27,52,8,23,38,53,9,60,31,30 +,39,27,37,14,14,34,8,29,58,10,25,3,19,37,11,35,52,39,48,24,22,19]; $self->{S_KEY} = $self->Make_shiftedKeys(); return; } ################################################# # PUBLIC Subroutine # ################################################# sub encipher($) { my $self = shift; my $MSG = shift;; $MSG = $self->Encode($self->Encode($MSG,$self->{R_KEY}),$self->{S_ +KEY}); return $MSG; } ################################################# # PUBLIC Subroutine # ################################################# sub decipher($) { my $self = shift; my $MSG = shift;; $MSG = $self->Decode($self->Decode($MSG,$self->{S_KEY}),$self->{R_ +KEY}); return $MSG; } ################################################# # PRIVATE Subroutine # ################################################# sub Make_shiftedKeys(){ my $self = shift; my $shift = $self->setAttribute(); $self->{S_KEY} = $self->modifyKeys(); if (($shift % 2) == 1){$self->{S_KEY} = (substr($self->{S_KEY},1,( +length $self->{S_KEY})));} else {$self->{S_KEY} = (substr($self->{S_KEY},0,(length $self->{S_ +KEY}) - 1));} my $key; my $v; for (my $i=0; $i <= ($shift - 1) % length $self->{S_KEY}; $i++){ + my $key = substr($self->{S_KEY},0,1); $v = ord($key) - 32; $self->{S_KEY} = (substr($self->{S_KEY},1,(length $self->{ +S_KEY}) - 1)); $self->{S_KEY} .= ord($v ^ $self->{RSORT}[$v] + 32); } return $self->{S_KEY}; } ################################################# # PRIVATE Subroutine # ################################################# sub setAttribute(){ my $self = shift; $self->{ATT} = 0x00; for (my $i=0; $i < (length $self->{R_KEY}); $i++){ $self->{ATT} = $self->{ATT} ^ (ord(substr($self->{R_KEY},$i,1) +) - 0x20); } return $self->{ATT}; } ################################################# # PRIVATE Subroutine # ################################################# sub modifyKeys(){ my $self = shift; my S_KEY = ""; my $i, $x; For $x = 1 To length($self->{R_KEY}) $i = ord(substr($self->{R_KEY}, $x, 1)) - 32 S_KEY = S_KEY + ord(($i ^ $self->{RSORT}[$i] ^ $self->{ATT}) + + 32) Next x return S_KEY; } ################################################# # PRIVATE Subroutine # ################################################# sub Encode($$){ my $self = shift; $self->{xString} = shift; $self->{cipher_key} = shift; $self->cipher(); return $self->{xStr}; } ################################################# # PRIVATE Subroutine # ################################################# sub Decode($$){ my $self = shift; $self->{xString} = shift; $self->{cipher_key} = shift; $self->cipher(); return $self->{xStr}; } ################################################# # PRIVATE Subroutine # ################################################# sub cipher(){ my $self = shift; $self->{xStr} = ""; my $keyval; my $xch; my @akeys = split "",$self->{cipher_key}; my $keylen = length $self->{cipher_key}; my $i = (length $self->{xString} % $keylen); # DATA DEPENDENT +SHIFT for(my $x=0; $x < length ($self->{xString}); $x++){ $keyval = ord($akeys[$i]) - 0x20; $xch = ord(substr($self->{xString},$x,1)); if ($xch > 0x7f){ $xch = $xch - 0x21;} if ($xch > 0x1f){ $xch = ($keyval ^ ($xch - 0x20)) + 0x20; # Apply ciph +er } if ($xch > 0x7f){ $xch = $xch + 0x21;} $self->{xStr} .= chr($xch); $i++; if ($i == $keylen){$i = 0;} } return; } 1;
      The cipher period is diffused to N*(N-1) message elements (where N is key length.) This significantly reduces data available for frequency analysis so that a 2K textarea window can be protected with a 15 character key if it is assumed that more than 5 key periods are required for analysis.
      Frequency analysis is not the only way to attack a cipher. A message encrypted with this system can be broken easily in only 2 key periods. Simply XOR the first N*(N-1) characters with the second N*(N-1), which removes the key entirely and leaves the difference of two chunks of plaintext. Using common words like "the" and "and" as a crib quickly produces enough of the original message for the key to be discovered.

      What if you don't know the key length to start with? Some well-chosen shifts and xors expose the redundancy in the N*(N-1) period, allowing it to be attacked with frequency analysis as though it had a length of only N+(N-1). I'll post the details if anyone cares. Once you have the key length, proceed as described above.

      And who am I? Not a professional cryptographer. I'm sure they have even better techniques. I'm a green amateur, armed only with what I've come up with over the course of the past week.

          
        A message encrypted with this system can be broken easily in only 2 ke +y periods
        That's not quite true. As you said, having only two key periods of message length means that when you XOR the two encrypted segments together, you are left with the XOR of the two plaintext segments. This is not usually enough information to reconstruct the original plaintext message, unless advanced statistical techniques enter the picture. To see why, consider that:
        ("case" ^ "hook") eq ("gone" ^ "lark")
        This is not an isolated case either, it's just the first I came up with after not more than a few minutes of randomly poking around with XOR.

          
        What if you don't know the key length to start with? Some well-chosen +shifts and xors expose the redundancy in the N*(N-1) period, allowing + it to be attacked with frequency analysis as though it had a length +of only N+(N-1).
        I'm not sure what you mean by attacking as though length was N+(N-1). You can reduce a double XOR of lengths N and N-1 to solving for N+(N-1) if you have known plaintext of that length, but I'm not aware of any other attacks that reduce the problem in that way.

        To find an unknown key length, however, is trivial. The standard technique for discovering an unknown key length is to try XORing the text against itself shifted at various distances, until you see a spike in the index of coincidence. The lowest common multiple of the spiked distances is then your key length.

        I'm not a professional cryptographer either, but I like to play one on perlmonks.com ;-)

           MeowChow                                   
                       s aamecha.s a..a\u$&owag.print
Re: CipherText
by Steeeeeve on Jul 17, 2001 at 17:35 UTC
    REVISED 6-17-01 debugs misuse of chr which was hurriedly carried over from Visual Basic implementation.

    An additional note on creating an ASCII compliant version: Restrict the keys domain to 32-63 but also create a randomly sorted set of these 32 values that when combined with the index give the actual sorted value. This implementation uses a set of 64 sorted values. Output domain of the ASCII version will be 32-127 while the output using this table and a key domain of 64 is 32-159 (32 non-ASCII values.)

    There was a minor problem transmitting values 128-159 using ISO-8859-1 largely because Windows implementations differ in regard to the characters chosen for 128, 141 and 158. (This range of the ISO-8859-1 is reserved for use as a set of control values, consequently it will tend to see some variations as implemented by companies world-wide that are not intended to seriously affect what is actually embodied in documents.) To get around this problem, it is necessary to shift the ISO-8859-1 characters used to represent ciphertext values 128-159 to a static set of characters. This is easily done by subtracting and add 33 before and after each cipher. The effect is to be able to create ciphertext on a Windows 95 system with one ISO-8859-1 implementation, and transmit it to a Windows 2000 system with another without a problem. Transmission equipment could also cause problems if the values are not shifted.

    # CipherTextI.pm # # Charles Prichard 6-16-01 # # ################################################# package CipherTextI; use strict; use integer; use bytes; ################################################# # PUBLIC Subroutine # ################################################# sub new($) { my $class = shift; my $self = {}; bless $self, ref $class || $class; $self->{xString} = undef; $self->{xStr} = undef; $self->{R_KEY} = undef; $self->{ATT} = undef; $self->{S_KEY} = undef; $self->{cipher_key} = undef; $self->{RSORT} = []; $self->init(@_); return $self; } sub init($){ my $self = shift; my ($params) = shift; my @temp1 = split /\;/, $params; my %params = (); my @temp2=(); foreach my $x (@temp1){ @temp2 = split /\=/, $x; $self->{$temp2[0]} = $temp2[1]; } $self->{RSORT} = [3,28,7,5,39,62,34,32,56,18,17,6,29,49,63,45,13,1 +3,29,40,2,17,17,9,12,61,56,23,55,37,31,13,27,52,8,23,38,53,9,60,31,30 +,39,27,37,14,14,34,8,29,58,10,25,3,19,37,11,35,52,39,48,24,22,19]; $self->{S_KEY} = $self->Make_shiftedKeys(); return; } ################################################# # PUBLIC Subroutine # ################################################# sub encipher($) { my $self = shift; my $MSG = shift;; $MSG = $self->Encode($self->Encode($MSG,$self->{R_KEY}),$self->{S_ +KEY}); return $MSG; } ################################################# # PUBLIC Subroutine # ################################################# sub decipher($) { my $self = shift; my $MSG = shift;; $MSG = $self->Decode($self->Decode($MSG,$self->{S_KEY}),$self->{R_ +KEY}); return $MSG; } ################################################# # PRIVATE Subroutine # ################################################# sub Make_shiftedKeys(){ my $self = shift; my $shift = $self->setAttribute(); $self->{S_KEY} = $self->modifyKeys(); if (($shift % 2) == 1){$self->{S_KEY} = (substr($self->{S_KEY},1,( +length $self->{S_KEY})));} else {$self->{S_KEY} = (substr($self->{S_KEY},0,(length $self->{S_ +KEY}) - 1));} my $key; my $v; for (my $i=0; $i <= ($shift - 1) % length $self->{S_KEY}; $i++){ + my $key = substr($self->{S_KEY},0,1); $v = ord($key) - 32; $self->{S_KEY} = (substr($self->{S_KEY},1,(length $self->{ +S_KEY}) - 1)); $self->{S_KEY} .= chr($v ^ $self->{RSORT}[$v] + 32); } return $self->{S_KEY}; } ################################################# # PRIVATE Subroutine # ################################################# sub setAttribute(){ my $self = shift; $self->{ATT} = 0x00; for (my $i=0; $i < (length $self->{R_KEY}); $i++){ $self->{ATT} = $self->{ATT} ^ (ord(substr($self->{R_KEY},$i,1) +) - 0x20); } return $self->{ATT}; } ################################################# # PRIVATE Subroutine # ################################################# sub modifyKeys(){ my $self = shift; my S_KEY = ""; my $i, $x; For $x = 1 To length($self->{R_KEY}) $i = ord(substr($self->{R_KEY}, $x, 1)) - 32 S_KEY = S_KEY + chr(($i ^ $self->{RSORT}[$i] ^ $self->{ATT}) + + 32) Next x return S_KEY; } ################################################# # PRIVATE Subroutine # ################################################# sub Encode($$){ my $self = shift; $self->{xString} = shift; $self->{cipher_key} = shift; $self->cipher(); return $self->{xStr}; } ################################################# # PRIVATE Subroutine # ################################################# sub Decode($$){ my $self = shift; $self->{xString} = shift; $self->{cipher_key} = shift; $self->cipher(); return $self->{xStr}; } ################################################# # PRIVATE Subroutine # ################################################# sub cipher(){ my $self = shift; $self->{xStr} = ""; my $keyval; my $xch; my @akeys = split "",$self->{cipher_key}; my $keylen = length $self->{cipher_key}; my $i = (length $self->{xString} % $keylen); # DATA DEPENDENT +SHIFT for(my $x=0; $x < length ($self->{xString}); $x++){ $keyval = ord($akeys[$i]) - 0x20; $xch = ord(substr($self->{xString},$x,1)); if ($xch > 0x7f){ $xch = $xch - 0x21;} if ($xch > 0x1f){ $xch = ($keyval ^ ($xch - 0x20)) + 0x20; # Apply ciph +er } if ($xch > 0x7f){ $xch = $xch + 0x21;} $self->{xStr} .= chr($xch); $i++; if ($i == $keylen){$i = 0;} } return; } 1;
      sub modifyKeys(){ my $self = shift; my S_KEY = ""; my $i, $x; For $x = 1 To length($self->{R_KEY}) $i = ord(substr($self->{R_KEY}, $x, 1)) - 32 S_KEY = S_KEY + chr(($i ^ $self->{RSORT}[$i] ^ $self->{ATT}) + 32) Next x return S_KEY; }

      I have gobs of problems with "programmers" that don't check their work and repeat the same mistake over and over.

        sub modifyKeys(){ my $self = shift; my S_KEY = ""; my $i; for (my $x = 0; x < length $self->{R_KEY}; $x++) { $i = ord(substr($self->{R_KEY}, $x, 1)) - 32 S_KEY = S_KEY + chr(($i ^ $self->{RSORT}[$i] ^ $self->{ATT}) + + 32) } return S_KEY; }
        Sorry. Download a template with the embedded javascript at: http://www.greentv.com/CipherText/CipherText.htm Steeeeeve

Back to Code Catacombs

Log In?
Username:
Password:

What's my password?
Create A New User
Node Status?
node history
Node Type: sourcecode [id://57072]
help
Chatterbox?
and the web crawler heard nothing...

How do I use this? | Other CB clients
Other Users?
Others avoiding work at the Monastery: (11)
As of 2014-07-25 14:57 GMT
Sections?
Information?
Find Nodes?
Leftovers?
    Voting Booth?

    My favorite superfluous repetitious redundant duplicative phrase is:









    Results (172 votes), past polls