సీజర్ సాంకేతిక లిపి - RotN సీజర్

సీజర్ సాంకేతిక లిపిని ప్రతిక్షేపణ సాంకేతిక లిపి అని కూడా పిలుస్తారు. ఇది రహస్య సమాచార బట్వాడా కోసం రకరకాల పద్ధతుల్లో ఓ మూడు నాలుగు దశాబ్దాల క్రితం వరకూ వాడుతూ వుండేవారు. ఇప్పటికీ వాడుతున్నారో లేదో నావద్ద సరైన సమాచారమైతే లేదు గానీ ఇది ప్రధానంగా అక్షరముల క్రమాన్ని మార్చడం ద్వారా సమాచారాన్ని ప్రత్యర్థులకు అర్థంకాకుండా చేస్తుంది.  ఉదాహరణగా “Rapid bits”  అనే పదాన్ని తీసుకొని ప్రతి అక్షరాన్ని మూడు అక్షరాల తరువాత వచ్చే అక్షరంతో ప్రతిక్షేపించినట్లైతే “udslg elwv”  గా మారుతుంది.  

 
ఈ పద్ధతినే మూడు అక్షరాలకు బదులు n th అక్షరానికి మార్చినట్లైతే రకరకాల combinations వస్తాయి. ఈ Encrypted message అక్షర స్థానాన్ని మార్చడం ద్వారా ఏర్పడుతుంది కాబట్టి ఈ క్రింది రెండు ఫార్ములాల ద్వారా encrypt/ decrypt చెయ్యవచ్చు. రహస్య సమాచార బదిలీ లో ఇది చాలా చాలా మొదటి మెట్టు అని గుర్తుంచుకోవాలి.

  C=E(P)=(P+n-1)%26  + 1
  P=D(C)=(C-n+25)%26 +1 

ఇక్కడ C= ciphered text , P= plain text, n= rotation number

ఆంగ్లంలో వున్నది 26 అక్షరాలే కాబట్టి అక్షర స్థాన చలనము 25 రకాలుగా మాత్రమే జరుగుతుంది. కానీ కంప్యూటర్ ద్వారా సమాచారాన్ని పంపేటప్పుడు అంకెలు, వేరే గుర్తులు కూడా వుంటాయి కాబట్టి దీని విస్తృతి మరికొంత పెరుగుతుంది. 
 

Rot5, Rot13, Rot18, Rot47  అనేవి చాలా ఎక్కువగా వాడేవారు. ఇంకా వాడుతున్నారేమో కూడా!. Rot అనేది Rotation కి సంక్షిప్త నామము. Rot5 అంటే ప్రతి అక్షరాన్ని 5 స్థానాల తరువాత వచ్చే అక్షరంతో ప్రతిక్షేపించారు. ఈ క్రింద కొన్ని C# లో వ్రాసిన scripts వున్నాయి.

)      RotN Encryptor
private string RotNEncrypt(string s, int n, bool includeNumbers)
        {
            string result = "";
            char[] carray = s.ToCharArray();
            for (int i = 0; i < carray.Length; i++)
            {
                int ascii = carray[i];
                int rot = ascii;
                if (ascii > 64 && ascii < 91)
                {
                    rot = rot + n;                  
                    if (rot > 90)
                    {
                        rot += -90 + 64;
                    }
                    if (rot < 65)
                    {
                        rot += -64 + 90;
                    }
                }
                // Lowercase letters are 97 to 122
                else if (ascii > 96 && ascii < 123)
                {
                    rot = rot + n;
                    if (rot > 122) rot += -122 + 96;
                    if (rot < 97) rot += -96 + 122;
                }
                // Numeric digits are 48 to 57
                if (includeNumbers == true && ascii > 47 && ascii < 58)
                {
                    rot = rot + n;
                    if (rot > 47) rot += -57 + 47;
                    if (rot < 58) rot += -47 + 57;
                }

                char character = (Char)rot;
                result = result + character.ToString();
            }
            return result;
        }


2)      Rot13 Encrypter and Decrypter

private string Rot13(string s)
        {
            if (String.IsNullOrEmpty(s)) return s;
            char[] character = s.ToCharArray();
            for (int i = 0; i < s.Length; i++)
            {
                char c = s[i];
                if (c >= 97 && c <= 122)
                {
                    int rot = c + 13;
                    if (rot > 122) rot -= 26;
                    character[i] = (char)rot;
                }
                else if (c >= 65 && c <= 90)
                {
                    int rot = c + 13;
                    if (rot > 90) rot -= 26;
                    character[i] = (char)rot;
                }
                else
                {
                    character[i] = c;
                }
            }
            return new string(character);
        }


3)      Rot47 Encryptor and Decryptor

private string Rot47(string s)
        {
            string cipher = "";
            foreach (char c in s.ToCharArray())
            {
                if (c != ' ')
                {
                    int rot = c;
                    rot += 47;
                    if (rot > 126) rot -= 94;
                    if (rot < 33) rot += 94;
                    cipher = cipher + (char)rot.ToString();
                }
                else
                {
                    cipher = cipher + " ";
                }
             
            }
            return cipher;
        }