319 lines
15 KiB
Plaintext
319 lines
15 KiB
Plaintext
using System;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Collections.Generic;
|
|
using System.Reflection;
|
|
using AniNIX.Shared;
|
|
|
|
namespace AniNIX.Crypto {
|
|
public class Workbench {
|
|
public string inputText { get; private set; }
|
|
public string workSpace { get; private set; }
|
|
public StringBuilder HelpText = new StringBuilder();
|
|
public Dictionary<String,Cipher> SwitchCases = new Dictionary<String,Cipher>();
|
|
// The workbench needs to maintain an instance of each ciphersuite for operation.
|
|
private List<Cipher> _ciphers = new List<Cipher>();
|
|
// If this is true, we will prevent prompt and filesystem access.
|
|
private bool _isBlind = false;
|
|
|
|
/// <summary>
|
|
/// Read in a cipher either from a filename or from stdin
|
|
/// <summary>
|
|
/// <param name="line">user input</param>
|
|
private void ReadCipher(String[] line) {
|
|
// If a filename's not provided.
|
|
if (line == null || line.Length !=2) {
|
|
Console.WriteLine("Please paste your ciphertext. End your input with a trailing newline.");
|
|
string readLn = Console.ReadLine();
|
|
StringBuilder sb = new StringBuilder();
|
|
//Read lines from stdin until a blank line is given.
|
|
while (readLn != null && !String.IsNullOrWhiteSpace((readLn))) {
|
|
sb.AppendLine(readLn);
|
|
readLn=Console.ReadLine();
|
|
}
|
|
// The user's input is the trimmed sum of the lines.
|
|
inputText = sb.ToString().Trim();
|
|
} else {
|
|
// Try to read the file into the input.
|
|
try {
|
|
StringBuilder sb = new StringBuilder();
|
|
StreamReader fileReader = new StreamReader(line[1]);
|
|
String lineR = fileReader.ReadLine();
|
|
while (lineR != null) {
|
|
sb.AppendLine(lineR);
|
|
lineR = fileReader.ReadLine();
|
|
}
|
|
fileReader.Dispose();
|
|
fileReader = null;
|
|
inputText = sb.ToString().Trim();
|
|
Console.WriteLine(String.Format("Read {0}",line[1]));
|
|
}
|
|
// If there's a problem, input is null.
|
|
catch (Exception e) {
|
|
Console.Error.WriteLine(e.Message);
|
|
inputText = null;
|
|
}
|
|
|
|
}
|
|
workSpace = inputText;
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create a new workbench from input.
|
|
/// </summary>
|
|
/// <param name="args">the arguments provided for execution</param>
|
|
public Workbench(string[] args) {
|
|
// If args are null, read from STDIN.
|
|
if (args.Length == 0) {
|
|
ReadCipher(null);
|
|
// If there's only one arg and that's --blind, set the blind option and read from stdin.
|
|
} else if (args.Length == 1) {
|
|
if (args[0].Equals("--blind")) {
|
|
this._isBlind = true;
|
|
ReadCipher(null);
|
|
// Otherwise, try to use the first argument as a filename.
|
|
} else if (args[0].Equals("--help") || args[0].Equals("-h")) {
|
|
} else {
|
|
String[] line = new String[2];
|
|
line[0] = "reread";
|
|
line[1] = args[0];
|
|
ReadCipher(line);
|
|
}
|
|
// Otherwise, give some help and exit.
|
|
} else {
|
|
Console.Error.WriteLine("The only argument allowed is a filename containing the ciphertext or --blind to block filesystem access.");
|
|
System.Environment.Exit(1);
|
|
}
|
|
// Seed the helptext.
|
|
HelpText.Append("Available commands:\n");
|
|
// Don't tell users about things they can't use.
|
|
if (!_isBlind) {
|
|
HelpText.Append("reread -- Read in a new cipher\n");
|
|
HelpText.Append("write -- write the workspace to a file\n");
|
|
}
|
|
HelpText.Append("reset -- reset workspace to the ciphertext.\n");
|
|
HelpText.Append("regex -- Check for strings with the two regex arguments: [search] [filter]\n");
|
|
HelpText.Append("links -- show some helpful links\n");
|
|
HelpText.Append("print -- show the current workspace\n");
|
|
HelpText.Append("display -- alias of print\n");
|
|
// Initialize the ciphersuites.
|
|
Object[] cipherArgs = { (Object)this };
|
|
foreach (Type cipherType in Assembly.GetAssembly(typeof(Cipher)).GetTypes()
|
|
.Where(myType => myType.IsClass && !myType.IsAbstract && myType.IsSubclassOf(typeof(Cipher)))) {
|
|
_ciphers.Add((Cipher)Activator.CreateInstance(cipherType, cipherArgs));
|
|
}
|
|
HelpText.Append("exit -- exit and show the result.\n");
|
|
HelpText.Append("quit -- alias of exit.\n");
|
|
HelpText.Append("help -- show this HelpText\n");
|
|
HelpText.Append("\nYou can get help on any command by running \"<command> help\".\nSuppress printing the cipher with a trailing ;.\n\nCommand structure is: {module} {operation} [{keypart}]*\n\nExample commands:\n\"caesar encrypt 13\" -- Encrypt the input with a Caesarian cipher of offset 13.\n\"affine help\" -- Get help on the Affine cipher.\n\"simple stripspace\" -- Use the Simple module to remove spaces.\n\"analysis one-to-one\" -- Check if the workspace is a one-to-one correlation with the input.\n\n");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Convert this workbench into a readable string.
|
|
/// </summary>
|
|
public override String ToString() {
|
|
StringBuilder currentStatus = new StringBuilder();
|
|
currentStatus.Append("Input:\n");
|
|
currentStatus.Append(this.inputText);
|
|
currentStatus.Append("\n");
|
|
currentStatus.Append("Workspace:\n");
|
|
currentStatus.Append(this.workSpace);
|
|
return currentStatus.ToString();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Display this workbench to stdout with colors.
|
|
/// </summary>
|
|
// <param name="verbose">Set to true if you want verbose prints.
|
|
public void Print() { Print(false); }
|
|
public void Print(bool verbose) {
|
|
Console.ForegroundColor = ConsoleColor.Red;
|
|
Console.WriteLine("Input:");
|
|
Console.ResetColor();
|
|
Console.WriteLine(this.inputText);
|
|
Console.ForegroundColor = ConsoleColor.Red;
|
|
Console.WriteLine("Workspace:");
|
|
Console.ResetColor();
|
|
if (verbose) return;
|
|
List<String> topletters = Analysis.GetMostCommonLetters(workSpace).Take(5).ToList();//cyan
|
|
List<String> bigrams = Analysis.Top(Analysis.GetSubstrings(workSpace,2)); //yellow
|
|
List<String> trigrams = Analysis.Top(Analysis.GetSubstrings(workSpace,3));//magenta
|
|
for (int i = 0; i < workSpace.Length; i++) {
|
|
if (i < workSpace.Length-1 && workSpace[i] == workSpace[i+1]) {
|
|
Console.ForegroundColor = ConsoleColor.Green;
|
|
Console.Write(workSpace[i++]);
|
|
|
|
} else if (i < workSpace.Length-2 && trigrams.Contains(workSpace.Substring(i,3))) {
|
|
Console.ForegroundColor = ConsoleColor.Magenta;
|
|
Console.Write(workSpace[i++]);
|
|
Console.Write(workSpace[i++]);
|
|
} else if (i < workSpace.Length-1 && bigrams.Contains(workSpace.Substring(i,2))) {
|
|
Console.ForegroundColor = ConsoleColor.Yellow;
|
|
Console.Write(workSpace[i++]);
|
|
} else if (topletters.Contains(workSpace[i].ToString())) {
|
|
Console.ForegroundColor = ConsoleColor.Cyan;
|
|
}
|
|
Console.Write(workSpace[i]);
|
|
Console.ResetColor();
|
|
}
|
|
Console.WriteLine();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Show some helpful links.
|
|
/// </summary>
|
|
public static void HelpfulLinks() {
|
|
StringBuilder linksText = new StringBuilder();
|
|
linksText.Append("http://www.visca.com/regexdict/ -- RegEx word dictionary\n");
|
|
linksText.Append("http://rumkin.com/tools/cipher/ -- Cipher tools\n");
|
|
linksText.Append("http://norvig.com/mayzner.html -- Frequency analysis\n");
|
|
Console.Write(linksText.ToString());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Save the workspace to a file
|
|
/// </summary>
|
|
/// <param name="workSpace"> what to write </param>
|
|
/// <param name="line"> user input, which should include a file</param>
|
|
public void WriteWorkspace(String workSpace, String[] line) {
|
|
// Require a filename.
|
|
if (line == null || line.Length != 2) {
|
|
Console.Error.WriteLine("Need a file.");
|
|
return;
|
|
}
|
|
try {
|
|
// If we are actually given a file, write the workspace to a file and close.
|
|
StreamWriter fileWriter = new StreamWriter(line[1],false);
|
|
fileWriter.WriteLine(workSpace);
|
|
fileWriter.Dispose();
|
|
fileWriter = null;
|
|
Console.WriteLine(String.Format("Wrote file {0}",line[1]));
|
|
} catch (Exception e) {
|
|
// Let the user know the file's not writeable.
|
|
Console.WriteLine(String.Format("Couldn't write file.\n{0}",e.Message));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Interact with the user.
|
|
/// </summary>
|
|
public void Run() {
|
|
// Display the header.
|
|
Console.ForegroundColor = ConsoleColor.Red;
|
|
Console.WriteLine("### Welcome to the AniNIX/CryptoWorkbench ###");
|
|
Console.ResetColor();
|
|
Console.WriteLine("Type help for assistance.\n");
|
|
Print();
|
|
try {
|
|
// Set the initial command to be show the helptext.
|
|
string command = "";
|
|
string read = "";
|
|
string[] line;
|
|
bool showCipher=true;
|
|
|
|
// Until the user exits...
|
|
while (command != "exit" && command != "quit") {
|
|
// parse shell-type command unification with semicolons
|
|
foreach (String executable in read.Split(';')) {
|
|
|
|
// If the command is only whitespace, continue and don't show the cipher.
|
|
if (String.IsNullOrWhiteSpace(executable)) {
|
|
showCipher = false; // if the last nonwhitespace character is a semicolon, we won't bother printing.
|
|
continue;
|
|
}
|
|
|
|
// Otherwise we will show the cipehr.
|
|
showCipher = true;
|
|
line = executable.Trim().Split(' ');
|
|
command = line[0];
|
|
// Command is first space-delimited entry.
|
|
switch (command) {
|
|
case "reread":
|
|
if (!_isBlind) ReadCipher(line);
|
|
break;
|
|
case "write":
|
|
if (!_isBlind) WriteWorkspace(workSpace,line);
|
|
break;
|
|
case "reset":
|
|
this.workSpace = this.inputText;
|
|
Console.Clear();
|
|
Console.WriteLine("Reset.");
|
|
break;
|
|
case "links":
|
|
HelpfulLinks();
|
|
break;
|
|
case "regex":
|
|
try {
|
|
if (line.Length == 3) {
|
|
Console.Write(ExecuteCommand.Run(String.Format("bash /opt/aninix/CryptoWorkbench/regex-lookup.bash \"{0}\" \"{1}\"",line[1].Replace("\\","\\\\").Replace("$","\\$"),line[2].Replace("\\","\\\\").Replace("$","\\$"))));
|
|
} else if (line.Length == 2) {
|
|
Console.Write(ExecuteCommand.Run(String.Format("bash /opt/aninix/CryptoWorkbench/regex-lookup.bash \"{0}\"",line[1].Replace("\\","\\\\").Replace("$","\\$"))));
|
|
Console.WriteLine();
|
|
} else {
|
|
Console.Error.WriteLine("Need at least one search term.");
|
|
}
|
|
} catch (Exception e) {
|
|
Console.Error.WriteLine(e.ToString());
|
|
}
|
|
break;
|
|
case "help":
|
|
Console.WriteLine(HelpText.ToString());
|
|
break;
|
|
case "display":
|
|
case "print":
|
|
showCipher = true;
|
|
break;
|
|
case "exit":
|
|
case "quit":
|
|
throw new Exception("");
|
|
default:
|
|
try {
|
|
workSpace = SwitchCases[command].RunCommand(this.workSpace,this.inputText,line);
|
|
} catch (Exception e) {
|
|
e.ToString();
|
|
Console.Error.WriteLine("Command not found.");
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Show the cipher if the user asked.
|
|
if (showCipher) Print();
|
|
// Display an AniNIX-standard prompt.
|
|
Console.Write("\nCW ");
|
|
Console.ForegroundColor = ConsoleColor.Red;
|
|
Console.Write("|");
|
|
Console.ResetColor();
|
|
Console.Write("> ");
|
|
read = Console.ReadLine().Trim();
|
|
}
|
|
// If we run into trouble, tell the user.
|
|
} catch (Exception e) {
|
|
Console.Error.WriteLine(e.Message);
|
|
}
|
|
|
|
// When we exit, show the result to the user.
|
|
finally {
|
|
Console.WriteLine("\nFinal result:");
|
|
this.Print();
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Create and execute a workbench program.
|
|
/// </summary>
|
|
public static void Main(string[] args) {
|
|
Workbench cw = new Workbench(args);
|
|
try {
|
|
cw.Run();
|
|
} catch (NullReferenceException e) {
|
|
Console.Error.WriteLine(String.Format("Caught {0}",e.GetType().ToString()));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|