public override ImageData Read(IBinaryStream stream, ImageMetaData info)
{
using (var proxy = new ProxyStream(stream.AsStream, true))
using (var crypt = new InputCryptoStream(proxy, new TigTransform()))
using (var input = new BinaryStream(crypt, stream.Name))
return(base.Read(input, info));
}
protected Handler(ProxyStream stream, CancellationToken token)
{
this.ProxyStream = stream;
this.CancelSource = CancellationTokenSource.CreateLinkedTokenSource(token);
this.CancelSource.Token.Register(stream.Close);
}
public async Task <HttpObj> ProcessAsync(ProcessItem item)
{
var boundary = MultipartRequestHelper.GetBoundary(
MediaTypeHeaderValue.Parse(item.HttpRequest.ContentType),
_defaultFormOptions.MultipartBoundaryLengthLimit);
var reader = new MultipartReader(boundary, item.HttpRequest.Body);
var section = await reader.ReadNextSectionAsync();
//body
ValidateSection(section);
var ms = new MemoryStream();
await section.Body.CopyToAsync(ms);
var body = Encoding.UTF8.GetString(ms.ToArray());
var dataObj = Helper.ToHttpDataObj(body, item.DataObjType !);
//stream
section = await reader.ReadNextSectionAsync();
ValidateSection(section);
var fileName = GetFileName(section.ContentDisposition);
if (fileName == null)
{
throw new ArgumentNullException("", "File name is null.");
}
dataObj.TrySetStreamName(fileName);
var proxyStream = new ProxyStream(section.Body, dataObj.StreamLength);
return(new HttpObj {
HttpDataObj = dataObj, ProxyStream = proxyStream
});
}
public async Task <(HttpDataObj obj, ProxyStream stream)> GetFromFormDataAsync(Type dataObjType)
{
var boundary = MultipartRequestHelper.GetBoundary(
MediaTypeHeaderValue.Parse(_context.Request.ContentType),
_defaultFormOptions.MultipartBoundaryLengthLimit);
var reader = new MultipartReader(boundary, _context.Request.Body);
var section = await reader.ReadNextSectionAsync();
//body
ValidateSection(section);
MemoryStream ms = new MemoryStream();
await section.Body.CopyToAsync(ms);
var body = Encoding.UTF8.GetString(ms.ToArray());
var dataObj = Helper.ToHttpDataObj(body, dataObjType);
//stream
section = await reader.ReadNextSectionAsync();
ValidateSection(section);
var fileName = GetFileName(section.ContentDisposition);
dataObj.TrySetStreamName(fileName);
var proxyStream = new ProxyStream(section.Body, dataObj.StreamLength);
return(dataObj, proxyStream);
}
public TunnelSslMitm(ProxyStream stream, CancellationToken token, X509Certificate2 certificate, SslProtocols sslProtocols, HandleFunc handler)
: base(stream, token)
{
this.m_sslProtocols = sslProtocols;
this.m_certificate = certificate;
this.m_handler = handler;
}
internal IBinaryStream OpenEncrypted(IBinaryStream stream, bool seekable = false)
{
Stream input = new ProxyStream(stream.AsStream, true);
input = new InputCryptoStream(input, new TigTransform());
if (seekable)
{
input = new SeekableStream(input);
}
return(new BinaryStream(input, stream.Name));
}
private void SocketThread(object socketObject)
{
using (var socket = (Socket)socketObject)
using (var stream = new NetworkStream(socket))
{
socket.ReceiveTimeout = 30 * 1000;
socket.SendTimeout = 30 * 1000;
stream.ReadTimeout = 30 * 1000;
stream.WriteTimeout = 30 * 1000;
var desc = $"{socket.LocalEndPoint} > {socket.RemoteEndPoint}";
LinkedListNode <Socket> socketNode;
this.m_connectionsBarrier.AddParticipant();
lock (this.m_connections)
{
socketNode = this.m_connections.AddLast(socket);
Console.WriteLine($"Connected {desc} ({this.m_connections.Count})");
}
try
{
using (var proxyStream = new ProxyStream(stream))
this.SocketThreadSub(proxyStream);
}
catch (Exception)
{
}
lock (this.m_connections)
{
this.m_connections.Remove(socketNode);
Console.WriteLine($"Disconnected {desc} {this.m_connections.Count}");
}
try
{
socket.Close();
}
catch
{
}
try
{
this.m_connectionsBarrier.RemoveParticipant();
}
catch
{
}
}
}
private void backgroundWorker1_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e)
{
// Init the python engine
ProxyStream InputStream = new ProxyStream(1000);
ProxyStream OutputStream = new ProxyStream(1000);
ProxyStream ErrorStream = new ProxyStream(1000);
ScriptEngine engine = Python.CreateEngine();
ScriptScope scope = engine.CreateScope();
StreamReader OutputReader = new StreamReader(OutputStream);
StreamWriter InputWriter = new StreamWriter(InputStream);
engine.Runtime.IO.SetInput(InputStream, Encoding.ASCII);
engine.Runtime.IO.SetOutput(OutputStream, Encoding.ASCII);
engine.Runtime.IO.SetErrorOutput(ErrorStream, Encoding.ASCII);
scope.SetVariable("Axis1", AXISID.AXIS1);
scope.SetVariable("Axis2", AXISID.AXIS2);
scope.SetVariable("Controller", DynamicHelpers.GetPythonTypeFromType(typeof(Controller)));
while (true)
{
if (Locked)
{
OutputStream.clean();
try
{
backgroundWorker1.ReportProgress(2, mShellCommands);
var code = engine.CreateScriptSourceFromString(mShellCommands);
code.Execute(scope);
}
catch (Exception ee)
{
backgroundWorker1.ReportProgress(1, ee.ToString());
//textBox2.AppendText(string.Format("{0}{1}", Environment.NewLine, ee));
}
Locked = false;
OutputStream.Position = 0;
backgroundWorker1.ReportProgress(0, OutputReader.ReadToEnd());
}
}
}
void RewriteSegment(NpkSegment segment, int chunk_size)
{
using (var proxy = new ProxyStream(m_archive, true))
using (var encryptor = m_aes.CreateEncryptor())
using (var output = new CryptoStream(proxy, encryptor, CryptoStreamMode.Write))
{
if (m_remaining == chunk_size)
{
m_input.CopyTo(output);
}
else
{
chunk_size = m_input.Read(m_buffer, 0, chunk_size);
output.Write(m_buffer, 0, chunk_size);
}
}
segment.UnpackedSize = segment.Size = (uint)chunk_size;
segment.AlignedSize = (uint)(m_archive.Position - segment.Offset);
}
//gets stream for reading uncompressed data
//only one stream can be used at the same time
public Stream GetStream(string fileName)
{
CentralDirectory dir = m_centralDirEntries.Where(d => d.fileName == fileName).First();
LocalFileHeader fileHeader = LocalFileHeader.Read(m_reader, dir);
switch (fileHeader.compressionMethod)
{
//no compression
case 0:
return(new ProxyStream(m_stream, dir.compressedSize));
//deflate
case 8:
var proxy = new ProxyStream(m_stream, dir.compressedSize);
return(new DeflateStream(proxy, CompressionMode.Decompress, true));
}
throw new NotSupportedException("Compression method not supported. Method id: " + fileHeader.compressionMethod);
}
NpkSegment WriteSegment(int chunk_size, bool compress)
{
var segment = new NpkSegment {
Offset = m_archive.Position
};
using (var proxy = new ProxyStream(m_archive, true))
using (var encryptor = m_aes.CreateEncryptor())
{
Stream output = new CryptoStream(proxy, encryptor, CryptoStreamMode.Write);
var measure = new CountedStream(output);
output = measure;
if (compress)
{
output = new DeflateStream(output, CompressionLevel.Optimal);
}
using (output)
{
if (m_remaining == chunk_size)
{
var file_pos = m_input.Position;
m_input.CopyTo(output);
m_input.Position = file_pos;
m_input.CopyTo(m_checksum_stream);
}
else
{
chunk_size = m_input.Read(m_buffer, 0, chunk_size);
output.Write(m_buffer, 0, chunk_size);
m_checksum_stream.Write(m_buffer, 0, chunk_size);
}
}
segment.UnpackedSize = (uint)chunk_size;
segment.Size = (uint)measure.Count;
segment.AlignedSize = (uint)(m_archive.Position - segment.Offset);
return(segment);
}
}
private ProxyRequest(Stream stream)
{
this.m_proxyStream = new ProxyStream(stream);
}
public override void Create(Stream output, IEnumerable <Entry> list, ResourceOptions options,
EntryCallback callback)
{
var npk_options = GetOptions <Npk2Options> (options);
if (null == npk_options.Key)
{
throw new InvalidEncryptionScheme();
}
var enc = DefaultEncoding.WithFatalFallback();
int index_length = 0;
var dir = new List <NpkStoredEntry>();
foreach (var entry in list)
{
var ext = Path.GetExtension(entry.Name).ToLowerInvariant();
var npk_entry = new NpkStoredEntry
{
Name = entry.Name,
RawName = enc.GetBytes(entry.Name.Replace('\\', '/')),
IsSolid = SolidFiles.Contains(ext),
IsPacked = !DisableCompression.Contains(ext),
};
int segment_count = 1;
if (!npk_entry.IsSolid)
{
segment_count = (int)(((long)entry.Size + DefaultSegmentSize - 1) / DefaultSegmentSize);
}
index_length += 3 + npk_entry.RawName.Length + 0x28 + segment_count * 0x14;
dir.Add(npk_entry);
}
index_length = (index_length + 0xF) & ~0xF;
int callback_count = 0;
using (var aes = Aes.Create())
{
aes.Mode = CipherMode.CBC;
aes.Padding = PaddingMode.PKCS7;
aes.Key = npk_options.Key;
aes.IV = GenerateAesIV();
output.Position = 0x20 + index_length;
foreach (var entry in dir)
{
if (null != callback)
{
callback(callback_count++, entry, arcStrings.MsgAddingFile);
}
using (var writer = new NpkWriter(entry, output, aes))
writer.Write(DefaultSegmentSize);
}
output.Position = 0;
var buffer = new byte[] { (byte)'N', (byte)'P', (byte)'K', (byte)'2', 1, 0, 0, 0 };
output.Write(buffer, 0, 8);
output.Write(aes.IV, 0, 0x10);
LittleEndian.Pack(dir.Count, buffer, 0);
LittleEndian.Pack(index_length, buffer, 4);
output.Write(buffer, 0, 8);
using (var encryptor = aes.CreateEncryptor())
using (var proxy = new ProxyStream(output, true))
using (var index_stream = new CryptoStream(proxy, encryptor, CryptoStreamMode.Write))
using (var index = new BinaryWriter(index_stream))
{
if (null != callback)
{
callback(callback_count++, null, arcStrings.MsgWritingIndex);
}
foreach (var entry in dir)
{
index.Write(entry.IsSolid); // 0 -> segmentation enabled, 1 -> no segmentation
index.Write((short)entry.RawName.Length);
index.Write(entry.RawName);
index.Write(entry.UnpackedSize);
index.Write(entry.CheckSum);
index.Write(entry.Segments.Count);
foreach (var segment in entry.Segments)
{
index.Write(segment.Offset);
index.Write(segment.AlignedSize);
index.Write(segment.Size);
index.Write(segment.UnpackedSize);
}
}
}
}
}
public HandlerPlain(ProxyStream stream, CancellationToken token, HandleFunc handler)
: base(stream, token)
{
this.m_handler = handler;
}
private void SocketThreadSub(ProxyStream proxyStream)
{
// https 연결인지, plain 인지 확인하는 과정
// ContentType type
// https://tools.ietf.org/html/rfc5246#page-41
var buff = new byte[1];
var read = proxyStream.Peek(buff, 0, buff.Length);
if (read != buff.Length)
{
throw new NotSupportedException();
}
if (buff[0] == 22)
{
var ssl = new SslStream(proxyStream, false);
ssl.AuthenticateAsServer(Certificates.Client, false, SslProtocol, false);
proxyStream = new ProxyStream(ssl);
}
Handler handler = null;
if (!ProxyRequest.TryParse(proxyStream, false, out var req))
{
return;
}
using (req)
{
// HTTPS
if (req.Method == "CONNECT")
{
// 호스트 확인하고 처리
switch (req.RemoteHost)
{
case "userstream.twitter.com":
case "api.twitter.com":
case "localhost":
case "127.0.0.1":
handler = new TunnelSslMitm(proxyStream, this.m_tunnelCancel.Token, Certificates.Client, SslProtocol, this.HandleContext);
break;
default:
handler = new TunnelSslForward(proxyStream, this.m_tunnelCancel.Token);
break;
}
}
// HTTP
else
{
// 호스트 확인하고 처리
switch (req.RemoteHost)
{
case "localhost":
case "127.0.0.1":
handler = new HandlerPlain(proxyStream, this.m_tunnelCancel.Token, this.HandleContext);
break;
default:
handler = new TunnelPlain(proxyStream, this.m_tunnelCancel.Token);
break;
}
}
using (handler)
handler.Handle(req);
}
}
public TunnelPlain(ProxyStream stream, CancellationToken token)
: base(stream, token)
{
}
Stream OpenStream(IBinaryStream input, uint key)
{
var proxy = new ProxyStream(input.AsStream, true);
return(new InputCryptoStream(proxy, new Ags32Transform(key)));
}
public TunnelSslForward(ProxyStream stream, CancellationToken token)
: base(stream, token)
{
}
