using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; // Utility Classes namespace AgnesAhlberg.Util { // A class to hold an array index map and its reverse public class IndexMap { #region Factory Methods public static IndexMap CreateShuffle(int length) { return new IndexMap(length); } public static IndexMap CreateRotation(int length, int steps) { return new IndexMap(length, steps); } #endregion #region Constructors private IndexMap(int length) { Type = "Shuffle"; Steps = null; EncMap = _makeShuffleEncMap(length); DecMap = _reverseMap(EncMap); } private IndexMap(int length, int steps) { Type = "Rotation"; Steps = steps; EncMap = _makeRotationEncMap(length, steps); DecMap = _reverseMap(EncMap); } #endregion #region Properties public string Type { get; } public int? Steps { get; } public int[] EncMap { get; } public int[] DecMap { get; } #endregion #region Internal Methods private int[] _makeShuffleEncMap(int length) { int[] encMap = new int[length]; for(int i = 0; i < length; i++) { encMap[i] = i; } var rd = new Random(); return encMap.OrderBy(x => rd.Next()).ToArray(); } private int[] _makeRotationEncMap(int length, int steps) { int[] encMap = new int[length]; for(int i = 0; i < length; i++) { encMap[i] = (i + steps) % length; } return encMap; } private int[] _reverseMap(int[] encMap) { int[] decMap = new int[encMap.Length]; for(int i = 0; i < encMap.Length; i++) { decMap[encMap[i]] = i; } return decMap; } #endregion } } // The CypherSuits namespace AgnesAhlberg.Security.CypherSuits { // Top-Level class is 'Cypher'. // It provides the basic encrypt and decrypt methods // One suit of cyphers are based on an index map for its // alphabet. Any permutation of the ordered index set is a valid // cypher method. Hence, the top-level index map based class // is 'PermutationCypher'. // A rotation of the index set is a special kind of permutation. // If the rotation is by 2, mapping 'A' -> 'C', it is a Caesar cypher, // if the rotation is by 13, it is a ROT13 cypher. // CaesarCypher and Rot13Cyper are thus subclasses of the RotationCypher, // which in turn is a permutation cypher. // Cypher // ^ // | // :--------------------------. // | | // PermutationCypher (?) // ^ [other cypher types] // | // RotationCypher // ^ // | // .-------------'----------------. // | | // CaesarCypher Rot13Cypher public abstract class Cypher { public abstract string encrypt(string plainText); public abstract string decrypt(string cypherText); } // this is the bulk of implementation, the others just set // different parameters. Isn't OOP great? :D public class PermutationCypher : Cypher { protected Util.IndexMap _indexMap; protected string _alphabet; public PermutationCypher(Util.IndexMap indexMap, string alphabet) { _indexMap = indexMap; _alphabet = alphabet; } public override string encrypt(string plainText) { return new string( plainText.Select(c => { var index = _alphabet.IndexOf(c); return index == -1 ? c : _alphabet[_indexMap.EncMap[index]]; }).ToArray() ); } public override string decrypt(string cypherText) { return new string( cypherText.Select(c => { var index = _alphabet.IndexOf(c); return index == -1 ? c : _alphabet[_indexMap.DecMap[index]]; }).ToArray() ); } } // specialisations public class RotationCypher : PermutationCypher { public RotationCypher(int steps, string alphabet) : base(Util.IndexMap.CreateRotation(alphabet.Length, steps), alphabet) { } } public class CaesarCypher : RotationCypher { public CaesarCypher(string alphabet) : base(2, alphabet) { } } public class Rot13Cypher : RotationCypher { public Rot13Cypher(string alphabet) : base(13, alphabet) { } } } // main program namespace AgnesAhlberg { using Security.CypherSuits; using Util; // cypher context class class Context where T : Cypher { private StringBuilder _sb; private T _cypher; private string _text; private bool _isClosed; public Context(T cypher) { _cypher = cypher; _sb = new StringBuilder(); _isClosed = false; _text = null; } public void Append(string text) { if(!_isClosed) _sb.Append(text); } // practising operator overload public static Context operator+(Context ctx, string text) { ctx.Append(text); return ctx; } public void Close() { if(!_isClosed) { _text = _sb.ToString(); _isClosed = true; } } public void Clear() { _sb.Clear(); _isClosed = false; _text = null; } #region Properties public string Encrypted { get { if(_isClosed) return _cypher.encrypt(_text); else return null; } } public string Decrypted { get { if(_isClosed) return _cypher.decrypt(_text); else return null; } } #endregion } // Main Program class class Program { static void demonstrate(string methd, string plainText, Context ctx) where T : Cypher { Console.WriteLine($"Method: {methd}\n"); ctx += plainText; ctx.Close(); var cypherText = ctx.Encrypted; Console.WriteLine(cypherText); ctx.Clear(); ctx += cypherText; ctx.Close(); Console.WriteLine(ctx.Decrypted); Console.WriteLine("\n-----\n"); } static void Main(string[] args) { var alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; // my shot at Strategy pattern var caesarCypher = new CaesarCypher(alphabet); var rot13Cypher = new Rot13Cypher(alphabet); var shuffleCypher = new PermutationCypher(IndexMap.CreateShuffle(alphabet.Length), alphabet); var caesarCtx = new Context(caesarCypher); var rot13Ctx = new Context(rot13Cypher); var shuffleCtx = new Context(shuffleCypher); var plainText = "YOU GUYS ARE THE BEST"; demonstrate("Caesar Cypher", plainText, caesarCtx); demonstrate("ROT13 Cypher", plainText, rot13Ctx); demonstrate("Shuffle Cypher", plainText, shuffleCtx); } } }

Cypher Suits - Strategy Pattern and OOP