public ITestResult Perform()
{
cipher.Init(true, param);
byte[] outBytes = new byte[input.Length];
cipher.ProcessBytes(input, 0, input.Length, outBytes, 0);
if (!Arrays.AreEqual(outBytes, output))
{
return(new SimpleTestResult(false, Name + ": failed - "
+ "expected " + Hex.ToHexString(output)
+ " got " + Hex.ToHexString(outBytes)));
}
cipher.Init(false, param);
cipher.ProcessBytes(output, 0, output.Length, outBytes, 0);
if (!Arrays.AreEqual(input, outBytes))
{
return(new SimpleTestResult(false, Name + ": failed reversal"));
}
return(new SimpleTestResult(true, Name + ": OKAY"));
}
public override byte[] ProcessBytes(byte[] input, int inOff, int length)
{
if (length < 1)
{
return(null);
}
byte[] array = new byte[length];
cipher.ProcessBytes(input, inOff, length, array, 0);
return(array);
}
public byte[] EncodePlaintext(byte type, byte[] plaintext, int offset, int len)
{
byte[] mac = writeMac.CalculateMac(type, plaintext, offset, len);
int size = len + mac.Length;
byte[] outbuf = new byte[size];
encryptCipher.ProcessBytes(plaintext, offset, len, outbuf, 0);
encryptCipher.ProcessBytes(mac, 0, mac.Length, outbuf, len);
return(outbuf);
}
public virtual byte[] EncodePlaintext(long seqNo, byte type, byte[] plaintext, int offset, int len)
{
if (usesNonce)
{
UpdateIV(encryptCipher, forEncryption: true, seqNo);
}
byte[] array = new byte[len + writeMac.Size];
encryptCipher.ProcessBytes(plaintext, offset, len, array, 0);
byte[] array2 = writeMac.CalculateMac(seqNo, type, plaintext, offset, len);
encryptCipher.ProcessBytes(array2, 0, array2.Length, array, len);
return(array);
}
public override byte[] ProcessBytes(
byte[] input,
int inOff,
int length)
{
if (length < 1)
return null;
byte[] output = new byte[length];
cipher.ProcessBytes(input, inOff, length, output, 0);
return output;
}
public byte[] Finalize(IStreamCipher pEncryptor)
{
//Log.Write(LogLevel.Warning, "\n{0}", this.Data.ToHEX(this.Data.Length));
byte[] oData = new byte[Data.Length];
pEncryptor.ProcessBytes(Data, 0, Data.Length, oData, 0);
return(oData);
}
public virtual byte[] EncodePlaintext(long seqNo, byte type, byte[] plaintext, int offset, int len)
{
if (usesNonce)
{
UpdateIV(encryptCipher, true, seqNo);
}
byte[] outBuf = new byte[len + writeMac.Size];
encryptCipher.ProcessBytes(plaintext, offset, len, outBuf, 0);
byte[] mac = writeMac.CalculateMac(seqNo, type, plaintext, offset, len);
encryptCipher.ProcessBytes(mac, 0, mac.Length, outBuf, len);
return(outBuf);
}
private void RunVector(IStreamCipher hc, string fileName, PeekableLineReader r, string vectorName)
{
// Console.WriteLine(fileName + " => " + vectorName);
string hexKey = ReadBlock(r);
string hexIV = ReadBlock(r);
ICipherParameters cp = new KeyParameter(Hex.Decode(hexKey));
cp = new ParametersWithIV(cp, Hex.Decode(hexIV));
hc.Init(true, cp);
byte[] input = new byte[64];
byte[] output = new byte[64];
byte[] digest = new byte[64];
int pos = 0;
for (;;)
{
string line1 = r.PeekLine().Trim();
int equalsPos = line1.IndexOf('=');
string lead = line1.Substring(0, equalsPos - 1);
string hexData = ReadBlock(r);
byte[] data = Hex.Decode(hexData);
if (lead.Equals("xor-digest"))
{
if (!Arrays.AreEqual(data, digest))
{
Fail("Failed in " + fileName + " for test vector: " + vectorName + " at " + lead);
// Console.WriteLine(fileName + " => " + vectorName + " failed at " + lead); return;
}
break;
}
int posA = lead.IndexOf('[');
int posB = lead.IndexOf("..");
int posC = lead.IndexOf(']');
int start = Int32.Parse(lead.Substring(posA + 1, posB - (posA + 1)));
int end = Int32.Parse(lead.Substring(posB + 2, posC - (posB + 2)));
if (start % 64 != 0 || (end - start != 63))
{
throw new InvalidOperationException(vectorName + ": " + lead + " not on 64 byte boundaries");
}
while (pos < end)
{
hc.ProcessBytes(input, 0, input.Length, output, 0);
xor(digest, output);
pos += 64;
}
if (!Arrays.AreEqual(data, output))
{
Fail("Failed in " + fileName + " for test vector: " + vectorName + " at " + lead);
// Console.WriteLine(fileName + " => " + vectorName + " failed at " + lead); return;
}
}
}
/// <exception cref="IOException"></exception>
public virtual byte[] DecodeCiphertext(long seqNo, byte type, byte[] ciphertext, int offset, int len)
{
/*
* draft-josefsson-salsa20-tls-04 2.1 Note that Salsa20 requires a 64-bit nonce. That
* nonce is updated on the encryption of every TLS record, and is set to be the 64-bit TLS
* record sequence number. In case of DTLS the 64-bit nonce is formed as the concatenation
* of the 16-bit epoch with the 48-bit sequence number.
*/
if (usesNonce)
{
UpdateIV(decryptCipher, false, seqNo);
}
int macSize = readMac.Size;
if (len < macSize)
{
throw new TlsFatalAlert(AlertDescription.decode_error);
}
int plaintextLength = len - macSize;
byte[] deciphered = new byte[len];
decryptCipher.ProcessBytes(ciphertext, offset, len, deciphered, 0);
CheckMac(seqNo, type, deciphered, plaintextLength, len, deciphered, 0, plaintextLength);
return(Arrays.CopyOfRange(deciphered, 0, plaintextLength));
}
protected virtual KeyParameter GenerateRecordMacKey(IStreamCipher cipher)
{
byte[] input = new byte[0x40];
cipher.ProcessBytes(input, 0, input.Length, input, 0);
KeyParameter parameter = new KeyParameter(input, 0, 0x20);
Arrays.Fill(input, 0);
return(parameter);
}
protected static KeyParameter GenerateRecordMacKey(IStreamCipher cipher, byte[] firstBlock)
{
cipher.ProcessBytes(firstBlock, 0, firstBlock.Length, firstBlock, 0);
KeyParameter macKey = new KeyParameter(firstBlock, 0, 32);
Arrays.Fill(firstBlock, (byte)0);
return(macKey);
}
protected virtual KeyParameter GenerateRecordMacKey(IStreamCipher cipher)
{
byte[] firstBlock = new byte[64];
cipher.ProcessBytes(firstBlock, 0, firstBlock.Length, firstBlock, 0);
KeyParameter macKey = new KeyParameter(firstBlock, 0, 32);
Arrays.Fill(firstBlock, (byte)0);
return(macKey);
}
public virtual BufferSegment EncodePlaintext(long seqNo, byte type, byte[] plaintext, int offset, int len)
{
if (usesNonce)
{
UpdateIV(encryptCipher, true, seqNo);
}
int outBufLength = len + writeMac.Size;
byte[] outBuf = BufferPool.Get(outBufLength, true);
encryptCipher.ProcessBytes(plaintext, offset, len, outBuf, 0);
BufferSegment mac = writeMac.CalculateMac(seqNo, type, plaintext, offset, len);
encryptCipher.ProcessBytes(mac.Data, mac.Offset, mac.Count, outBuf, len);
BufferPool.Release(mac);
return(new BufferSegment(outBuf, 0, outBufLength));
}
protected virtual KeyParameter GenerateRecordMacKey(IStreamCipher cipher)
{
byte[] firstBlock = new byte[64];
cipher.ProcessBytes(firstBlock, 0, firstBlock.Length, firstBlock, 0);
// NOTE: The BC implementation puts 'r' after 'k'
Array.Copy(firstBlock, 0, firstBlock, 32, 16);
Poly1305KeyGenerator.Clamp(firstBlock, 16);
KeyParameter macKey = new KeyParameter(firstBlock, 16, 32);
Arrays.Fill(firstBlock, (byte)0);
return(macKey);
}
private void CheckReset(IStreamCipher cipher, ICipherParameters cipherParams,
bool encrypt, byte[] pretext, byte[] posttext)
{
// Do initial run
byte[] output = new byte[posttext.Length];
cipher.ProcessBytes(pretext, 0, pretext.Length, output, 0);
// Check encrypt resets cipher
cipher.Init(encrypt, cipherParams);
try
{
cipher.ProcessBytes(pretext, 0, pretext.Length, output, 0);
}
catch (Exception e)
{
Fail(cipher.AlgorithmName + " init did not reset: " + e.Message);
}
if (!Arrays.AreEqual(output, posttext))
{
Fail(cipher.AlgorithmName + " init did not reset.", Hex.ToHexString(posttext), Hex.ToHexString(output));
}
// Check reset resets data
cipher.Reset();
try
{
cipher.ProcessBytes(pretext, 0, pretext.Length, output, 0);
}
catch (Exception e)
{
Fail(cipher.AlgorithmName + " reset did not reset: " + e.Message);
}
if (!Arrays.AreEqual(output, posttext))
{
Fail(cipher.AlgorithmName + " reset did not reset.");
}
}
public virtual byte[] EncodePlaintext(long seqNo, byte type, byte[] plaintext, int offset, int len)
{
/*
* draft-josefsson-salsa20-tls-04 2.1 Note that Salsa20 requires a 64-bit nonce. That
* nonce is updated on the encryption of every TLS record, and is set to be the 64-bit TLS
* record sequence number. In case of DTLS the 64-bit nonce is formed as the concatenation
* of the 16-bit epoch with the 48-bit sequence number.
*/
if (usesNonce)
{
UpdateIV(encryptCipher, true, seqNo);
}
byte[] outBuf = new byte[len + writeMac.Size];
encryptCipher.ProcessBytes(plaintext, offset, len, outBuf, 0);
byte[] mac = writeMac.CalculateMac(seqNo, type, plaintext, offset, len);
encryptCipher.ProcessBytes(mac, 0, mac.Length, outBuf, len);
return(outBuf);
}
public override void PerformTest()
{
cipher.Init(true, param);
byte[] outBytes = new byte[input.Length];
cipher.ProcessBytes(input, 0, input.Length, outBytes, 0);
if (!Arrays.AreEqual(outBytes, output))
{
Fail("failed - "
+ "expected " + Hex.ToHexString(output)
+ " got " + Hex.ToHexString(outBytes));
}
cipher.Init(false, param);
cipher.ProcessBytes(output, 0, output.Length, outBytes, 0);
if (!Arrays.AreEqual(input, outBytes))
{
Fail("failed reversal");
}
}
public byte[] Construct(IStreamCipher encryptor, ZStream dStream)
{
Log.Write(LogLevel.Client, "Constructing Packet [{0}]", GetType().ToString());
byte[] cData = _stream.ToArray();
//Log.Write(LogLevel.Error, "{0}", cData.ToHEX());
if (_def)
{
MemoryStream lStream = new MemoryStream();
dStream.avail_in = cData.Length;
dStream.next_in = cData;
dStream.next_in_index = 0;
byte[] dData = new byte[cData.Length * 2];
dStream.avail_out = cData.Length * 2;
dStream.next_out = dData;
dStream.next_out_index = 0;
dStream.deflate(2);
lStream.Write(dData, 0, (cData.Length * 2) - dStream.avail_out);
cData = lStream.ToArray();
lStream.Dispose();
}
MemoryStream oStream = new MemoryStream();
EndianBinaryWriter oWriter = new EndianBinaryWriter(MiscUtil.Conversion.EndianBitConverter.Little, oStream);
oWriter.Write((byte)GetModule());
oWriter.Write((UInt32)cData.Length + 2);
oWriter.Write((byte)GenerateChecksum(oStream.ToArray()));
oWriter.Write(cData, 0, cData.Length - 4);
byte[] fData = oStream.ToArray();
if (_enc)
{
byte[] eData = new byte[fData.Length];
encryptor.ProcessBytes(fData, 0, fData.Length, eData, 0);
fData = eData;
}
return(fData);
}
protected static KeyParameter GenerateRecordMacKey(IStreamCipher cipher, byte[] firstBlock)
{
cipher.ProcessBytes(firstBlock, 0, firstBlock.Length, firstBlock, 0);
if (_macKey == null)
{
_macKey = new KeyParameter(firstBlock, 0, 32);
}
else
{
_macKey.Reset();
_macKey.SetKey(firstBlock, 0, 32);
}
Arrays.Fill(firstBlock, (byte)0);
return(_macKey);
}
private void TestReset(IStreamCipher cipher1, IStreamCipher cipher2, ICipherParameters cipherParams)
{
cipher1.Init(true, cipherParams);
byte[] plaintext = new byte[1023];
byte[] ciphertext = new byte[plaintext.Length];
// Establish baseline answer
cipher1.ProcessBytes(plaintext, 0, plaintext.Length, ciphertext, 0);
// Test encryption resets
CheckReset(cipher1, cipherParams, true, plaintext, ciphertext);
// Test decryption resets with fresh instance
cipher2.Init(false, cipherParams);
CheckReset(cipher2, cipherParams, false, ciphertext, plaintext);
}
private void TestReset(IStreamCipher cipher1, IStreamCipher cipher2, ICipherParameters cipherParams)
{
cipher1.Init(true, cipherParams);
byte[] plaintext = new byte[1023];
byte[] ciphertext = new byte[plaintext.Length];
// Establish baseline answer
cipher1.ProcessBytes(plaintext, 0, plaintext.Length, ciphertext, 0);
// Test encryption resets
CheckReset(cipher1, cipherParams, true, plaintext, ciphertext);
// Test decryption resets with fresh instance
cipher2.Init(false, cipherParams);
CheckReset(cipher2, cipherParams, false, ciphertext, plaintext);
}
public virtual byte[] DecodeCiphertext(long seqNo, byte type, byte[] ciphertext, int offset, int len)
{
if (usesNonce)
{
UpdateIV(decryptCipher, forEncryption: false, seqNo);
}
int size = readMac.Size;
if (len < size)
{
throw new TlsFatalAlert(50);
}
int num = len - size;
byte[] array = new byte[len];
decryptCipher.ProcessBytes(ciphertext, offset, len, array, 0);
CheckMac(seqNo, type, array, num, len, array, 0, num);
return(Arrays.CopyOfRange(array, 0, num));
}
public byte[] DecodeCiphertext(byte type, byte[] ciphertext, int offset, int len)
{
byte[] deciphered = new byte[len];
decryptCipher.ProcessBytes(ciphertext, offset, len, deciphered, 0);
int plaintextSize = deciphered.Length - readMac.Size;
byte[] plainText = CopyData(deciphered, 0, plaintextSize);
byte[] receivedMac = CopyData(deciphered, plaintextSize, readMac.Size);
byte[] computedMac = readMac.CalculateMac(type, plainText, 0, plainText.Length);
if (!Arrays.ConstantTimeAreEqual(receivedMac, computedMac))
{
throw new TlsFatalAlert(AlertDescription.bad_record_mac);
}
return(plainText);
}
/// <exception cref="IOException"></exception>
public virtual byte[] DecodeCiphertext(long seqNo, byte type, byte[] ciphertext, int offset, int len)
{
if (usesNonce)
{
UpdateIV(decryptCipher, false, seqNo);
}
int macSize = readMac.Size;
if (len < macSize)
{
throw new TlsFatalAlert(AlertDescription.decode_error);
}
int plaintextLength = len - macSize;
byte[] deciphered = new byte[len];
decryptCipher.ProcessBytes(ciphertext, offset, len, deciphered, 0);
CheckMac(seqNo, type, deciphered, plaintextLength, len, deciphered, 0, plaintextLength);
return(Arrays.CopyOfRange(deciphered, 0, plaintextLength));
}
private void CheckReset(IStreamCipher cipher, ICipherParameters cipherParams,
bool encrypt, byte[] pretext, byte[] posttext)
{
// Do initial run
byte[] output = new byte[posttext.Length];
cipher.ProcessBytes(pretext, 0, pretext.Length, output, 0);
// Check encrypt resets cipher
cipher.Init(encrypt, cipherParams);
try
{
cipher.ProcessBytes(pretext, 0, pretext.Length, output, 0);
}
catch (Exception e)
{
Fail(cipher.AlgorithmName + " init did not reset: " + e.Message);
}
if (!Arrays.AreEqual(output, posttext))
{
Fail(cipher.AlgorithmName + " init did not reset.", Hex.ToHexString(posttext), Hex.ToHexString(output));
}
// Check reset resets data
cipher.Reset();
try
{
cipher.ProcessBytes(pretext, 0, pretext.Length, output, 0);
}
catch (Exception e)
{
Fail(cipher.AlgorithmName + " reset did not reset: " + e.Message);
}
if (!Arrays.AreEqual(output, posttext))
{
Fail(cipher.AlgorithmName + " reset did not reset.");
}
}
public PacketStream(List <byte[]> inPack, IStreamCipher Decryptor, ZStream Inflater)
{
Packets = new List <Packet>();
byte[] inBuff = inPack[0];
byte[] decData = new byte[inBuff.Length];
Decryptor.ProcessBytes(inBuff, 0, inBuff.Length, decData, 0);
MemoryStream IStream = new MemoryStream(decData);
EndianBinaryReader IReader = new EndianBinaryReader(MiscUtil.Conversion.BigEndianBitConverter.Little, IStream);
int remLength = decData.Length;
do
{
byte Module = IReader.ReadByte();
int pLength = IReader.ReadInt32();
int pChecksum = IReader.ReadByte();
if (VerifyChecksum(decData, pChecksum, (int)IReader.BaseStream.Position - 6))
{
byte[] Data;
if (inPack.Count > 1)
{
// Multipart packet
byte[] NewBuff = new byte[pLength - 6];
int curIndex = remLength - 6;
Array.Copy(IReader.ReadBytes(remLength - 6), 0, NewBuff, 0, remLength - 6);
for (int i = 1; i < inPack.Count; i++)
{
byte[] packDec = new byte[inPack[i].Length];
Decryptor.ProcessBytes(inPack[i], 0, inPack[i].Length, packDec, 0);
Array.Copy(packDec, 0, NewBuff, curIndex, packDec.Length);
curIndex += packDec.Length;
}
Data = NewBuff;
}
else
{
Data = IReader.ReadBytes(pLength - 6);
}
Packet iPacket = new Packet();
iPacket.Module = Module;
iPacket.Data = Decompress(Data, Inflater);
iPacket.Stream = new MemoryStream(iPacket.Data);
iPacket.Reader = new EndianBinaryReader(MiscUtil.Conversion.EndianBitConverter.Little, iPacket.Stream);
iPacket.PacketID = iPacket.Reader.ReadUInt32();
//if (iPacket.PacketID == 0x34287945)
// Console.WriteLine(decData.ToHEX());
iPacket.Reader.ReadUInt32();
//iPacket.IsValid = true;
Packets.Add(iPacket);
}
else
{
Console.WriteLine("Failure!!!!", inBuff.ToHEX(), decData.ToHEX());
break;
}
remLength -= pLength;
}while (remLength > 0);
IReader.Close();
IStream.Close();
}
public PacketStream(byte[] mpBuffer, int mpLength, IStreamCipher mpDecryptor, ZStream iStream, bool IsHandshake = false)
{
Packets = new List <Packet>();
if (IsHandshake)
{
MemoryStream Stream = new MemoryStream(mpBuffer);
EndianBinaryReader Reader = new EndianBinaryReader(MiscUtil.Conversion.BigEndianBitConverter.Little, Stream);
Reader.ReadByte();
int Length = Reader.ReadInt32();
Reader.ReadBytes(5);
byte[] Data = Reader.ReadBytes(Length - 10);
string RSAStr = Encoding.ASCII.GetString(Data);
Packet iPacket = new Packet();
iPacket.RSAData = new byte[RSAStr.Length / 2];
for (int i = 0; i < RSAStr.Length; i += 2)
{
iPacket.RSAData[i / 2] = byte.Parse(RSAStr.Substring(i, 2), NumberStyles.HexNumber);
}
Reader.Close();
Stream.Close();
Packets.Add(iPacket);
}
else
{
Packets = new List <Packet>();
byte[] dBuffer = new byte[mpLength];
mpDecryptor.ProcessBytes(mpBuffer, 0, mpLength, dBuffer, 0);
MemoryStream Stream = new MemoryStream(dBuffer);
EndianBinaryReader Reader = new EndianBinaryReader(MiscUtil.Conversion.BigEndianBitConverter.Little, Stream);
int remLength = mpLength;
do
{
Packet iPacket = new Packet();
iPacket.Module = Reader.ReadByte();
int pLength = Reader.ReadInt32();
int pChecksum = Reader.ReadByte();
try
{
if (iPacket.VerifyChecksum(dBuffer, pChecksum, (int)Reader.BaseStream.Position - 6))
{
byte[] iData = Reader.ReadBytes(pLength - 6);
//Console.WriteLine("#########################################\n{0}", iData.ToHEX());
byte[] Data = Decompress(iData, iStream);
if (Data.Length >= 4)
{
iPacket.Stream = new MemoryStream(Data);
iPacket.Reader = new EndianBinaryReader(MiscUtil.Conversion.EndianBitConverter.Little, iPacket.Stream);
iPacket.PacketID = (CPacketType)iPacket.Reader.ReadUInt32();
iPacket.Reader.ReadUInt32();
iPacket.IsValid = true;
byte[] cData = new byte[pLength];
Array.Copy(dBuffer, 0, cData, 0, pLength);
iPacket.Data = Data;
Packets.Add(iPacket);
}
}
}
catch { }
remLength -= pLength;
}while (remLength > 0);
Reader.Close();
Stream.Close();
}
}
protected virtual KeyParameter GenerateRecordMacKey(IStreamCipher cipher)
{
byte[] firstBlock = new byte[64];
cipher.ProcessBytes(firstBlock, 0, firstBlock.Length, firstBlock, 0);
KeyParameter macKey = new KeyParameter(firstBlock, 0, 32);
Arrays.Fill(firstBlock, (byte)0);
return macKey;
}
protected virtual KeyParameter GenerateRecordMacKey(IStreamCipher cipher)
{
byte[] firstBlock = new byte[64];
cipher.ProcessBytes(firstBlock, 0, firstBlock.Length, firstBlock, 0);
// NOTE: The BC implementation puts 'r' after 'k'
Array.Copy(firstBlock, 0, firstBlock, 32, 16);
Poly1305KeyGenerator.Clamp(firstBlock, 16);
KeyParameter macKey = new KeyParameter(firstBlock, 16, 32);
Arrays.Fill(firstBlock, (byte)0);
return macKey;
}
private void RunVector(IStreamCipher hc, string fileName, PeekableLineReader r, string vectorName)
{
// Console.WriteLine(fileName + " => " + vectorName);
string hexKey = ReadBlock(r);
string hexIV = ReadBlock(r);
ICipherParameters cp = new KeyParameter(Hex.Decode(hexKey));
cp = new ParametersWithIV(cp, Hex.Decode(hexIV));
hc.Init(true, cp);
byte[] input = new byte[64];
byte[] output = new byte[64];
byte[] digest = new byte[64];
int pos = 0;
for (;;)
{
string line1 = r.PeekLine().Trim();
int equalsPos = line1.IndexOf('=');
string lead = line1.Substring(0, equalsPos - 1);
string hexData = ReadBlock(r);
byte[] data = Hex.Decode(hexData);
if (lead.Equals("xor-digest"))
{
if (!Arrays.AreEqual(data, digest))
{
Fail("Failed in " + fileName + " for test vector: " + vectorName + " at " + lead);
// Console.WriteLine(fileName + " => " + vectorName + " failed at " + lead); return;
}
break;
}
int posA = lead.IndexOf('[');
int posB = lead.IndexOf("..");
int posC = lead.IndexOf(']');
int start = Int32.Parse(lead.Substring(posA + 1, posB - (posA + 1)));
int end = Int32.Parse(lead.Substring(posB + 2, posC - (posB + 2)));
if (start % 64 != 0 || (end - start != 63))
throw new InvalidOperationException(vectorName + ": " + lead + " not on 64 byte boundaries");
while (pos < end)
{
hc.ProcessBytes(input, 0, input.Length, output, 0);
xor(digest, output);
pos += 64;
}
if (!Arrays.AreEqual(data, output))
{
Fail("Failed in " + fileName + " for test vector: " + vectorName + " at " + lead);
// Console.WriteLine(fileName + " => " + vectorName + " failed at " + lead); return;
}
}
}
public string DoEncrypt(string symmetricStreamAlgorithm, string key, string IV,
string plainText)
{
this.GetError().cleanError();
SymmetricStreamAlgorithm algorithm = SymmetricStreamAlgorithmUtils.getSymmetricStreamAlgorithm(symmetricStreamAlgorithm, this.GetError());
if (this.GetError().existsError())
{
return("");
}
IStreamCipher engine = getCipherEngine(algorithm);
if (this.GetError().existsError())
{
return("");
}
/* KeyParameter keyParam = new KeyParameter(Hex.Decode(key));
* engine.Init(true, keyParam);*/
byte[] keyBytes = SecurityUtils.GetHexa(key, "SS007", this.error);
byte[] ivBytes = SecurityUtils.GetHexa(IV, "SS007", this.error);
if (this.HasError())
{
return("");
}
KeyParameter keyParam = new KeyParameter(keyBytes);
if (SymmetricStreamAlgorithmUtils.usesIV(algorithm, this.GetError()))
{
if (!this.GetError().existsError())
{
ParametersWithIV keyParamWithIV = new ParametersWithIV(keyParam, ivBytes);
try
{
engine.Init(false, keyParamWithIV);
}catch (Exception e)
{
this.error.setError("SS008", e.Message);
return("");
}
}
}
else
{
try
{
engine.Init(false, keyParam);
}catch (Exception e)
{
this.error.setError("SS009", e.Message);
return("");
}
}
EncodingUtil eu = new EncodingUtil();
byte[] input = eu.getBytes(plainText);
if (eu.GetError().existsError())
{
this.error = eu.GetError();
return("");
}
byte[] output = new byte[input.Length];
engine.ProcessBytes(input, 0, input.Length, output, 0);
if (output == null || output.Length == 0)
{
this.GetError().setError("SS004", "Stream encryption exception");
return("");
}
this.GetError().cleanError();
return(Base64.ToBase64String(output));
}
