protected override void Execute(CodeActivityContext context)
{
var key = Key.Get(context);
var iv = IV.Get(context);
var cipherText = CipherText.Get(context);
if (cipherText == null || cipherText.Length <= 0)
{
throw new ArgumentNullException("cipherText");
}
if (key == null || key.Length <= 0)
{
throw new ArgumentNullException("key");
}
string plaintext = null;
using (AesManaged aes = new AesManaged())
{
ICryptoTransform decryptor = aes.CreateDecryptor(Encoding.UTF8.GetBytes(key), Encoding.UTF8.GetBytes(iv));
using (MemoryStream ms = new MemoryStream(Convert.FromBase64String(cipherText)))
{
using (CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read))
{
using (StreamReader reader = new StreamReader(cs))
plaintext = reader.ReadToEnd();
}
}
}
PlainText.Set(context, plaintext);
}
//Método de evento para o clique no botão "Descriptografar"
private void Decrypt_Click(object sender, EventArgs e)
{
this.Encrypt.Enabled = true;
control = true;
//Verifica se a caixa do texto cifrado não está vazia
if (cipher.Length != 0)
{
//O texto descriptografado é enviado para uma string
string plain = AES.Decrypt(cipher, key, iv);
//A caixa de texto recebe o texto descriptografado que está na string
CipherText.Text = plain;
//Desativa o botão "Descriptografar"
this.Decrypt.Enabled = false;
}
else
{
MessageBox.Show("criptografe algo para poder descriptografar!", "Caixa de texto vazia!",
MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
CipherText.Clear();
plain_text.Clear();
plain_text.Focus();
}
}
/// <summary>
/// May I have a new command that wraps and encrypts an inner command, to be transmitted securely?
/// </summary>
/// <param name="parent">The parent-station sending the command.</param>
/// <param name="to">The address of the recipient.</param>
/// <param name="innerCommand">The command to be wrapped.</param>
public CryptoCommand(Station parent, IPEndPoint to, ICommand innerCommand)
{
Contract.Requires(parent != null);
Contract.Requires(to != null);
Contract.Requires(innerCommand != null);
Sender = parent.Address;
var crypto = parent.Crypto;
var cmdBytes = Bytes.From(innerCommand);
var symmetricKey = crypto.GenerateSymmetricKey();
crypto.NewIv();
var symmetricallyEncryptedCmdBytes = crypto.SymmetricEncrypt(cmdBytes, new SymmetricKey(symmetricKey));
var targetKey = parent.IsManager && to.Equals(parent.Address) ? parent.Crypto.Keys.Item1 : parent.Peers[to];
var asymKeyBytes = crypto.AsymmetricEncrypt(symmetricKey, new AsymmetricKey(targetKey));
var senderHashBytes = crypto.AsymmetricEncrypt(crypto.Hash(cmdBytes), new AsymmetricKey(crypto.Keys.Item2));
var symmetricKeyCipher = new CipherText(asymKeyBytes);
var commandCipher = new CipherText(symmetricallyEncryptedCmdBytes);
var senderHash = new CipherText(senderHashBytes);
var iv = crypto.Iv;
_content = new Message(symmetricKeyCipher, commandCipher, senderHash, iv);
}
public void TestToString()
{
var testSubject = new CipherText
{
adata = "atada",
cipher = "rehpic",
ct = "tc",
iter = 1000,
iv = "vi",
ks = 1000,
mode = "edom",
v = 1,
salt = "tlas",
ts = 1
};
var testResult = testSubject.ToString();
Assert.IsNotNull(testResult);
Assert.IsFalse(String.IsNullOrWhiteSpace(testResult));
Assert.IsTrue(testResult.Contains(string.Format("\"adata\":\"{0}\"", testSubject.adata)));
Assert.IsTrue(testResult.Contains(string.Format("\"cipher\":\"{0}\"", testSubject.cipher)));
Assert.IsTrue(testResult.Contains(string.Format("\"ct\":\"{0}\"", testSubject.ct)));
Assert.IsTrue(testResult.Contains(string.Format("\"iter\":{0}", testSubject.iter)));
Assert.IsTrue(testResult.Contains(string.Format("\"iv\":\"{0}\"", testSubject.iv)));
Assert.IsTrue(testResult.Contains(string.Format("\"ks\":{0}", testSubject.ks)));
Assert.IsTrue(testResult.Contains(string.Format("\"mode\":\"{0}\"", testSubject.mode)));
Assert.IsTrue(testResult.Contains(string.Format("\"v\":{0}", testSubject.v)));
Assert.IsTrue(testResult.Contains(string.Format("\"salt\":\"{0}\"", testSubject.salt)));
Assert.IsTrue(testResult.Contains(string.Format("\"ts\":{0}", testSubject.ts)));
}
public void TestTryParse()
{
var testValues = new CipherText
{
adata = "atada",
cipher = "rehpic",
ct = "tc",
iter = 1000,
iv = "vi",
ks = 1000,
mode = "edom",
v = 1,
salt = "tlas",
ts = 1
};
var toStringBuilder = new StringBuilder();
toStringBuilder.Append("{");
toStringBuilder.Append(string.Format("\"adata\":\"{0}\",", testValues.adata));
toStringBuilder.Append(string.Format("\"cipher\":\"{0}\",", testValues.cipher));
toStringBuilder.Append(string.Format("\"iter\":{0},", testValues.iter));
toStringBuilder.Append(string.Format("\"iv\":\"{0}\",", testValues.iv));
toStringBuilder.Append(string.Format("\"ks\":{0},", testValues.ks));
toStringBuilder.Append(string.Format("\"mode\":\"{0}\",", testValues.mode));
toStringBuilder.Append(string.Format("\"v\":{0},", testValues.v));
toStringBuilder.Append(string.Format("\"salt\":\"{0}\",", testValues.salt));
toStringBuilder.Append(string.Format("\"ts\":{0},", testValues.ts));
toStringBuilder.Append(string.Format("\"ct\":\"{0}\"", testValues.ct));
toStringBuilder.Append("}");
CipherText testSubject;
var testResult = CipherText.TryParse(toStringBuilder.ToString(), out testSubject);
Assert.IsTrue(testResult);
}
public override string ToString()
{
return(String.Format("{0}.{1}.{2}.{3}.{4}", Header.ToBase64String(),
EncryptedMasterKey.ToBase64String(),
InitializationVector.ToBase64String(),
CipherText.ToBase64String(),
Tag.ToBase64String()));
}
public byte[] SymmetricDecrypt(CipherText cipher, SymmetricKey symmetricKey)
{
_cipher.Init(
false,
new ParametersWithIV(
new KeyParameter(symmetricKey), Iv));
return(_cipher.DoFinal(cipher));
}
public void ReverseMessage(string message)
{
CipherText del = ShiftUpCharacters;
char[] reversedMsg = del(message).ToCharArray();
Array.Reverse(reversedMsg);
Console.WriteLine(reversedMsg);
}
/*
* /// <summary>
* /// The cpr test.
* /// </summary>
* [Test] public void CPRTest() {
* var cpr = new CPR(2312881133);
* Assert.That(cpr.Value == 2312881133);
* Assert.That(cpr.ToString().Equals("2312881133"));
* Assert.That(2312881133.Equals(cpr));
* }
*/
/// <summary>
/// The cipher text test.
/// </summary>
[Test] public void CipherTextTest()
{
var bytes = new byte[] { 1, 2, 3, 4, 5, 6 };
var cipher = new CipherText(bytes);
Assert.That(bytes.IsIdenticalTo(cipher));
Assert.That(bytes.IsIdenticalTo(cipher.Value));
Assert.That(cipher.ToString() != null);
}
private void Clear_Click(object sender, EventArgs e)
{
HashText.Clear();
PlainText.Clear();
CipherText.Clear();
PlainText.Focus();
this.Encryption.Enabled = true;
}
public static string ToPlainText(CipherText encryptedData, string bulkCipherKey)
{
//js and C# string escape seq's are the same...
var results =
Resources.ScriptEngine.Evaluate(string.Format("sjcl.decrypt(\"{0}\", \"{1}\" )",
bulkCipherKey,
encryptedData.ToString().Replace("\"", "\\\"")));
return(results.ToString());
}
/// <summary>
/// Convert this payload to Base64Url string
/// </summary>
/// <returns></returns>
public string SerializeToBase64UrlString()
{
return(String.Format("{0}.{1}.{2}.{3}.{4}",
Header.GetBase64UrlFromNormalString(),
EncryptedMasterKey.ToBase64UrlString(),
InitializationVector.ToBase64UrlString(),
CipherText.ToBase64UrlString(),
Tag.ToBase64UrlString()
));
}
private void Decrypt_Click(object sender, EventArgs e)
{
CipherText.Clear();
this.Decrypt.Enabled = false;
this.Encryption.Enabled = true;
UnicodeEncoding code = new UnicodeEncoding();
CipherText.Text += code.GetString(enc);
}
//Método de evento para o clique no botão "Limpar"
private void Clear_Click(object sender, EventArgs e)
{
//Limpa todas as caixas de texto
CipherText.Clear();
plain_text.Clear();
TextHash.Clear();
//Foca o mouse na primeira caixa
plain_text.Focus();
this.Encrypt.Enabled = true;
}
public static CipherText ToEncryptedText(string plainText, string bulkCipherKey)
{
var results = Resources.ScriptEngine.Evaluate(string.Format("sjcl.encrypt(\"{0}\",\"{1}\")", bulkCipherKey, plainText));
CipherText cipherText;
if (CipherText.TryParse(results.ToString(), out cipherText))
{
return(cipherText);
}
return(null);
}
public void EncryptedVoterDataTest()
{
var voternumber = new CipherText(new byte[] { 2, 1 });
var cpr = new CipherText(new byte[] { 3, 2 });
var ballotstatus = new CipherText(new byte[] { 4, 3 });
var encVoterData = new EncryptedVoterData(voternumber, cpr, ballotstatus);
Assert.That(voternumber.Equals(encVoterData.VoterNumber));
Assert.That(cpr.Equals(encVoterData.CPR));
Assert.That(ballotstatus.Equals(encVoterData.BallotStatus));
Assert.That(encVoterData.ToString() != null);
}
/// <summary>
/// The symmetric test.
/// </summary>
[Test] public void SymmetricTest()
{
var key = new SymmetricKey(Crypto.GenerateSymmetricKey());
const string TestString = "Howdy there, partner!";
byte[] bytes = Bytes.From(TestString);
CipherText ciphertext = Crypto.SymmetricEncrypt(bytes, key);
Assert.That(!bytes.IsIdenticalTo(ciphertext));
byte[] decryptedBytes = Crypto.SymmetricDecrypt(ciphertext, key);
Assert.That(bytes.IsIdenticalTo(decryptedBytes));
Assert.That(decryptedBytes.To <string>().Equals(TestString));
}
/// <summary>
/// Test asymmetric crypto features of Crypto subsystem.
/// </summary>
public void AsymmetricTest(string testString)
{
Contract.Requires(testString != null);
// Encrypt/decrypt
byte[] bytes = Bytes.From(testString);
CipherText ciphertext = Crypto.AsymmetricEncrypt(bytes,
new AsymmetricKey(Crypto.KeyPair.Public));
Assert.That(!bytes.IsIdenticalTo(ciphertext));
byte[] decryptedBytes = Crypto.AsymmetricDecrypt(ciphertext,
new AsymmetricKey(Crypto.KeyPair.Private));
Assert.That(bytes.IsIdenticalTo(decryptedBytes));
Assert.That(decryptedBytes.To <string>().Equals(testString));
}
public string SolveChallenge()
{
var decipheredTexts = new List <DecipherText>();
foreach (var cipher in _ciphers)
{
var cipherText = new CipherText(cipher, CipherTextFormat.HEXADECIMAL);
decipheredTexts.Add(cipherText.Crack(_cracker, KEYLENGTH));
}
decipheredTexts.Sort();
return(decipheredTexts.First().CipherText.Text);
}
public byte[] Execute(byte[] arg)
{
var cipherTextString = Encoding.UTF8.GetString(arg);
CipherText cipherText;
if (!CipherText.TryParse(cipherTextString, out cipherText))
{
throw new ArgumentException(string.Format("the cipher text could not be parsed \n '{0}'", cipherTextString));
}
var plainText = NoFuture.Encryption.Sjcl.BulkCipherKey.ToPlainText(cipherText, _bulkCipherKey);
return(Encoding.UTF8.GetBytes(plainText));
}
[Pure] public byte[] AsymmetricDecrypt(CipherText cipher,
AsymmetricKey asymmetricKey)
{
//_aCipher.Init(false, asymmetricKey.Value);
byte[] plainText =
AsymmetricProcessBuffer(cipher.Value, asymmetricKey);
return(new CipherText(plainText));
/* int outputLength =
* _aCipher.ProcessBytes(cipher.Value, 0, cipher.Value.Length, plainText, 0);
* outputLength += _aCipher.DoFinal(plainText, outputLength);
* byte[] result = new byte[outputLength];
* Array.Copy(plainText, result, outputLength);
* return new CipherText(result); */
}
/// <summary>
/// The message test.
/// </summary>
[Test] public void MessageTest()
{
var symKey = new CipherText(new byte[] { 1, 2 });
var cmd = new CipherText(new byte[] { 2, 3 });
var senderHash = new CipherText(new byte[] { 3, 4 });
var iv = new byte[] { 5, 6 };
var msg = new Message(symKey, cmd, senderHash, iv);
Assert.That(msg.SymmetricKey.Equals(symKey));
Assert.That(msg.Command.Equals(cmd));
Assert.That(msg.SenderHash.Equals(senderHash));
Assert.That(msg.Iv.IsIdenticalTo(iv));
Assert.That(msg.ToString() != null);
}
private void Decrypt()
{
try
{
if (Validate(false))
{
var plaintext = DES.Decrypt(
CipherText.FromHexStringToBitArray(),
Key.FromHexStringToBitArray());
PlainText = plaintext.ToHexString();
}
}
catch (Exception e)
{
ShowMessage(string.Format("Error: {0}", e));
}
}
public void ToggleStringJson()
{
var testValues = new CipherText
{
adata = "atada",
cipher = "rehpic",
ct = "tc",
iter = 1000,
iv = "vi",
ks = 1000,
mode = "edom",
v = 1,
salt = "tlas",
ts = 1
};
CipherText testSubject;
var testResultTryParse = CipherText.TryParse(testValues.ToString(), out testSubject);
Assert.IsTrue(testResultTryParse);
}
public IBuffer GetBufferWithoutHMAC()
{
bool usesPassword = (Options & (byte)1) == (byte)1;
using (var ms = new MemoryStream((int)(HEADER_LENGTH + CipherText.Length)))
using (var writer = new BinaryWriter(ms))
{
writer.Write(Version);
writer.Write(Options);
if (usesPassword)
{
writer.Write(EncryptionSalt.ToByteArray());
writer.Write(HMACSalt.ToByteArray());
}
writer.Write(IV.ToByteArray());
writer.Write(CipherText.ToByteArray());
return(ms.ToArray().ToBuffer());
}
}
public State()
{
Message = System.IO.File.ReadAllText(@"C:\Users\kuba1\Desktop\crypt\crypt\AES\Jakub_Pilimon.txt");
using (AesManaged aes = new AesManaged())
{
Key = aes.Key;
IV = aes.IV;
}
CipherText = Encypt(Message, Key, IV);
InvalidCipher = new byte[CipherText.Length];
CipherText.CopyTo(InvalidCipher, 0);
InvalidCipher[0] += 1;
InvalidKey = new byte[Key.Length];
Key.CopyTo(InvalidKey, 0);
InvalidKey[0] += 1;
}
public static byte[] Encrypt(byte[] input, uint ms)
{
var ct = new CipherText(input, ms);
var iv = Cipher8FromRand(ref ms);
//encrypt
foreach (var bytes in ct.Content)
{
for (var j = 0; j < 256; j++)
{
bytes[j] ^= iv[j];
}
var temp2 = new uint[0x100 / 4];
Buffer.BlockCopy(bytes, 0, temp2, 0, 0x100);
ShufflesLegacy.Shuffle2(temp2);
Buffer.BlockCopy(temp2, 0, iv, 0, 0x100);
Buffer.BlockCopy(temp2, 0, bytes, 0, 0x100);
}
return(ct.GetBytes(ref ms));
}
//private static byte makeIntegrityByte(byte rand)
//{
// char lastbyte = rand->rand();
// char tmp = lastbyte & 0xf3;
// return ((~tmp & 0x67) | (tmp & 0x98)) ^ 0x77 | (tmp & 0x10);
//}
public byte[] Encrypt(byte[] input, uint ms)
{
CipherText ct = new CipherText(input, ms);
byte[] iv = cipher8_from_rand(ref ms);
//encrypt
for (int i = 0; i < ct.content.Count; i++)
{
for (int j = 0; j < 256; j++)
{
ct.content[i][j] ^= iv[j];
}
uint[] temp2 = new uint[0x100 / 4];
Buffer.BlockCopy(ct.content[i], 0, temp2, 0, 0x100);
Shuffles.Shuffle2(temp2);
Buffer.BlockCopy(temp2, 0, iv, 0, 0x100);
Buffer.BlockCopy(temp2, 0, ct.content[i], 0, 0x100);
}
return(ct.getBytes(ref ms));
}
public Challenge6(string cipherText, ICracker cracker)
{
_cipherText = new CipherText(cipherText, CipherTextFormat.BASE64);
_cracker = cracker;
}
public byte[] SymmetricDecrypt(CipherText cipher, SymmetricKey symmetricKey)
{
Contract.Ensures(Contract.Result <byte[]>() != null);
return(default(byte[]));
}