/**
* <summary>
* <para>Data Criação: 31/03/2020</para>
* <para>Método síncrono que verifica se existe uma personalização da saída de comandos powershell.</para>
* <paramref name="CMD"/> Representa o pacote de comando enviado pelo cliente para execução no ambiente powershell.
* <para>Retorno: Boolean</para>
* </summary>
* */
private bool Get_ComandosPersonalizados(Pacote_Comando CMD = null)
{
string Comando = CMD?.Comando;
if (Comando != null && Comando != "")
{
char[] Separador = new char[] { ' ' };
string[] Partes_Comando = Comando.Split(Separador, StringSplitOptions.None);
Partes_Comando[0] = Partes_Comando[0].Replace("-", "_");
System.Reflection.MethodInfo Metodo = GetType().GetMethod(Partes_Comando[0]);
if (Metodo != null)
{
switch (Partes_Comando[0])
{
case "get_process":
if (get_process(Partes_Comando))
{
return(true);
}
else
{
return(false);
}
case "get_childrem":
if (get_childrem(Partes_Comando))
{
return(true);
}
else
{
return(false);
}
default:
break;
}
}
return(false);
}
else
{
return(false);
}
}
/**
* Data: 02/04/2019
* Transforma uma string em pacote para acesso.
* Return: string
*/
private dynamic DeserializarPacote(string Pacote)
{
try
{
Base = JsonConvert.DeserializeObject <Pacote_Base>(Pacote);
switch (Base.Pacote)
{
case TipoPacote.Auth:
Pacote_Auth Auth = JsonConvert.DeserializeObject <Pacote_Auth>(Base.Conteudo);
return(Auth);
case TipoPacote.Comando:
Pacote_Comando Exec = JsonConvert.DeserializeObject <Pacote_Comando>(Base.Conteudo);
return(Exec);
case TipoPacote.File:
Pacote_File File = JsonConvert.DeserializeObject <Pacote_File>(Base.Conteudo);
return(File);
case TipoPacote.FileSystem:
Pacote_SystemFile FileSystem = JsonConvert.DeserializeObject <Pacote_SystemFile>(Base.Conteudo);
return(FileSystem);
case TipoPacote.Echo:
Pacote_PingEcho Ping = JsonConvert.DeserializeObject <Pacote_PingEcho>(Base.Conteudo);
return(Ping);
case TipoPacote.Replay:
Pacote_PingReplay Replay = JsonConvert.DeserializeObject <Pacote_PingReplay>(Base.Conteudo);
return(Replay);
case TipoPacote.Inicializacao:
Pacote_Inicializacao Inicializacao = JsonConvert.DeserializeObject <Pacote_Inicializacao>(Base.Conteudo);
return(Inicializacao);
default:
throw new Exception("Tentativa de envio de pacote não reconhecida pelo sistema.");
}
}
catch (Exception e)
{
TratadorErros(e, this.GetType().Name);;
return(false);
}
}
/**
* Data: 03/03/2020
* Método para chamar, de uma classe informada, a execução e resposta por streamReader
* Return: False
*/
private string _ResponderRequisicao(Pacote_Comando pct)
{
try
{
bool DadosEnviar = _CMDs.Route(pct);
if (DadosEnviar)
{
return(_CMDs.Get_Resultado());
}
else
{
return(null);
}
}
catch (Exception e)
{
TratadorErros(e, this.GetType().Name);;
return(null);
}
}
/**
* <summary>
* Converte uma string em uma classe de pacote.
* </summary>
*/
private dynamic DeserializarPacote(string Pacote)
{
Pacote_Base Base = JsonConvert.DeserializeObject <Pacote_Base>(Pacote);
switch (Base.Pacote)
{
case TipoPacote.Auth:
Pacote_Auth Auth = JsonConvert.DeserializeObject <Pacote_Auth>(Base.Conteudo);
return(Auth);
case TipoPacote.Comando:
Pacote_Comando Exec = JsonConvert.DeserializeObject <Pacote_Comando>(Base.Conteudo);
return(Exec);
case TipoPacote.File:
Pacote_File File = JsonConvert.DeserializeObject <Pacote_File>(Base.Conteudo);
return(File);
case TipoPacote.FileSystem:
Pacote_SystemFile FileSystem = JsonConvert.DeserializeObject <Pacote_SystemFile>(Base.Conteudo);
return(FileSystem);
case TipoPacote.Echo:
Pacote_PingEcho Ping = JsonConvert.DeserializeObject <Pacote_PingEcho>(Base.Conteudo);
return(Ping);
case TipoPacote.Replay:
Pacote_PingReplay Replay = JsonConvert.DeserializeObject <Pacote_PingReplay>(Base.Conteudo);
return(Replay);
case TipoPacote.Inicializacao:
Pacote_Inicializacao Inicializacao = JsonConvert.DeserializeObject <Pacote_Inicializacao>(Base.Conteudo);
return(Inicializacao);
}
return(null);
}
public bool Route(Pacote_Comando PCT)
{
TSaida = PCT.Formato;
if (Get_ComandosPersonalizados(PCT))
{
return(true);
}
if ((ExecutarScript(PCT.Comando)) && (PCT.Comando != ""))
{
if (gerarSaida())
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
/**
* Data: 27/03/2019
* Método que recebe a requisição WEB do cliente, trata e a responde.
*/
private void Receber_Dados_Responder(object Dados)
{
Pacote_Error P_Error;
HttpListenerContext Conexao = Dados as HttpListenerContext;
HttpListenerRequest ObterConteudo = Conexao.Request;
StreamReader _Conteudo = new StreamReader(ObterConteudo.InputStream);
HttpListenerResponse ObterResposta = Conexao.Response;
try
{
string __Conteudo = _Conteudo.ReadLine();
/*-----------------------Processamento----------------------------*/
dynamic QTP = DeserializarPacote(__Conteudo);
switch (Base.Pacote)
{
case TipoPacote.Comando:
Pacote_Comando CMM = (Pacote_Comando)QTP; //Transforma string em um objeto da classe Pacote_Auth
bool _Autenticado = (bool)_Auth.HTML_Autenticado(CMM.Chave);
if (!_Autenticado)
{
throw new Exception("Usuário não autenticado.");
}
_GerenciadorCliente?.ConectarCliente(Conexao.Request.RemoteEndPoint, _Autenticado);
string Executar = _ResponderRequisicao(CMM);
if (Excecao)
{
P_Error = new Pacote_Error();
P_Error.Error = Excecao;
P_Error.Mensagem = DadosExcecao.Message;
P_Error.Tracer = DadosExcecao.StackTrace;
Executar = SerializarPacote(P_Error);
Excecao = false;
DadosExcecao = null;
}
Pacote_Comando PCT = new Pacote_Comando();
PCT.Resposta = Executar;
string DadosPacote = SerializarPacote(PCT);
//Obtém o Barramento de escrita com a cliente
ObterResposta.ContentLength64 = DadosPacote.Length;
ObterResposta.OutputStream.Write(ASCIIEncoding.UTF8.GetBytes(DadosPacote), 0, DadosPacote.Length);
ObterResposta.Close();
break;
case TipoPacote.Echo:
Pacote_PingReplay RPY = new Pacote_PingReplay();
DadosPacote = SerializarPacote(RPY);
//Obtém o Barramento de escrita com a cliente
ObterResposta.ContentLength64 = DadosPacote.Length;
ObterResposta.OutputStream.Write(ASCIIEncoding.UTF8.GetBytes(DadosPacote), 0, DadosPacote.Length);
ObterResposta.Close();
break;
default:
P_Error = new Pacote_Error();
P_Error.Error = true;
P_Error.Mensagem = "Esse tipo de pacote não existe.";
P_Error.Tracer = "";
DadosPacote = SerializarPacote(P_Error);
ObterResposta.ContentLength64 = DadosPacote.Length;
ObterResposta.OutputStream.Write(ASCIIEncoding.UTF8.GetBytes(DadosPacote), 0, DadosPacote.Length);
ObterResposta.Close();
break;
}
}
catch (Exception e)
{
TratadorErros(e, this.GetType().Name);
P_Error = new Pacote_Error();
P_Error.Error = Excecao;
P_Error.Mensagem = DadosExcecao.Message;
P_Error.Tracer = DadosExcecao.StackTrace;
string Erros = SerializarPacote(P_Error);
ObterResposta.ContentLength64 = Erros.Length;
ObterResposta.OutputStream.Write(ASCIIEncoding.UTF8.GetBytes(Erros), 0, Erros.Length);
ObterResposta.Close();
Excecao = false;
DadosExcecao = null;
}
}
/**
* Data: 27/02/2019
* Método que cria os barramentos de leitura e escrita, dá início ao diálogo inicial com os clientes e
* e dá início à conversa contínua com os cliente.
* Return: void
*/
private void Receber_Dados_Responder(object Dados)
{
StreamReader BarramentoLeitura;
StreamWriter BarramentoEscrita;
Pacote_Error P_Error;
try
{
TcpClient Clients = (TcpClient)Dados;
Func <string, bool> Falha = (G) => {
if (G == null)
{
EndPoint Fl = Clients.Client.RemoteEndPoint;
throw new Exception("Ocorreu uma falha no Servidor: " + Fl.ToString());
}
else
{
return(true);
}
};
using (NetworkStream Brrm = Clients.GetStream())
{
//Barramento de Leitura, após a abertura do socket
BarramentoLeitura = new StreamReader(Brrm);
//Obtém o Barramento de escrita com a cliente
BarramentoEscrita = new StreamWriter(Brrm);
string DadosLidos = BarramentoLeitura.ReadLine();
Falha(DadosLidos);//Verifica se o barramento é nulo, caracterizando uma falha na comunicação.
Pacote_PingEcho Echo = DeserializarPacote(DadosLidos);
/*Verifica se, cliente e servidor estão em sintonia, ocorreu algum erro*/
if (Echo.GetTipoPacote() != TipoPacote.Echo)
{
Pacote_PingReplay Replay = new Pacote_PingReplay();
Replay.Validado = false;
Replay.ObterTempo();
/*Confirma o recebimento, do cliente, inicialização.*/
BarramentoEscrita.WriteLine(SerializarPacote(Replay));
BarramentoEscrita.Flush();
throw new Exception("Falha de comunicação inicial: Cliente");
}
else
{
Pacote_PingReplay Replay = new Pacote_PingReplay();
Replay.Validado = true;
Replay.ObterTempo();
/*Confirma o recebimento, do cliente, inicialização.*/
BarramentoEscrita.WriteLine(SerializarPacote(Replay));
BarramentoEscrita.Flush();
}
DadosLidos = BarramentoLeitura.ReadLine();
Falha(DadosLidos);//Verifica se o barramento é nulo, caracterizando uma falha na comunicação.
string EnviarDadosCliente = TratarInicializacao(DadosLidos);
/*Informa ao cliente que os parâmetros de inicialização foram recebidos com sucesso.*/
BarramentoEscrita.WriteLine(EnviarDadosCliente);
BarramentoEscrita.Flush();
/*Processo de leitura do pacote de autenticação.*/
DadosLidos = BarramentoLeitura.ReadLine();
Falha(DadosLidos); //Verifica se o barramento é nulo, caracterizando uma falha na comunicação.
Pacote_Auth PTC = DeserializarPacote(DadosLidos); //Transforma string em um objeto da classe Pacote_Auth
PTC.TEndPointServer = TEndPoint;
PTC.DominioServidor = EDominio;
Pacote_Auth _Autenticado = _Auth?.AutenticarUsuario(PTC);
if (_Autenticado != null)
{
_GerenciadorCliente?.ConectarCliente(Clients.Client.RemoteEndPoint, _Autenticado);
EnviarDadosCliente = SerializarPacote(_Autenticado);
BarramentoEscrita.WriteLine(EnviarDadosCliente);
BarramentoEscrita.Flush();
//Leitura do barramento de dados do próximo tipo de pacote
DadosLidos = BarramentoLeitura.ReadLine();
Falha(DadosLidos);//Verifica se o barramento é nulo, caracterizando uma falha na comunicação.
dynamic QTP = DeserializarPacote(DadosLidos);
switch (Base.Pacote)
{
case TipoPacote.Comando:
Pacote_Comando CMM = (Pacote_Comando)QTP; //Transforma string em um objeto da classe Pacote_Auth
string Executar = _ResponderRequisicao(CMM);
if (Excecao)
{
P_Error = new Pacote_Error();
P_Error.Error = Excecao;
P_Error.Mensagem = DadosExcecao.Message;
P_Error.Tracer = DadosExcecao.StackTrace;
Executar = SerializarPacote(P_Error);
Excecao = false;
DadosExcecao = null;
}
Pacote_Comando PCT = new Pacote_Comando();
PCT.Resposta = Executar;
string DadosPacote = SerializarPacote(PCT);
//Obtém o Barramento de escrita com a cliente
BarramentoEscrita.WriteLine(DadosPacote);
BarramentoEscrita.Flush();
break;
case TipoPacote.Echo:
Pacote_PingReplay RPY = new Pacote_PingReplay();
DadosPacote = SerializarPacote(RPY);
//Obtém o Barramento de escrita com a cliente
BarramentoEscrita.WriteLine(DadosPacote);
BarramentoEscrita.Flush();
break;
case TipoPacote.File:
Pacote_File FILE = (Pacote_File)QTP;
string PathFile = FILE.Path;
int ReceiveBufferClienteSize = FILE.ReceiveBufferCLiente; //Armazena o tamanho do buffer de recepção do cliente;
int SendBufferClienteSize = FILE.SendBufferCliente; //Armazena o tamanho do buffer de envio do cliente;
int ReceiveBufferServerSize = Clients.ReceiveBufferSize; //Armazena o tamanho do buffer de recepção do cliente;
int SendBufferServerSize = Clients.SendBufferSize; //Armazena o tamanho do buffer de envio do cliente;
//Enviando dados dos buffers do servidor
FILE.ReceiveBufferServidor = ReceiveBufferServerSize; //Envia para o server a capacidade de recepção
FILE.SendBufferServidor = SendBufferServerSize; //envia para o server capacidade o tamanho de envio;
int BufferTransmissao = ReceiveBufferClienteSize > SendBufferServerSize ? SendBufferServerSize : ReceiveBufferClienteSize;
FILE.Existe = File.Exists(PathFile);
if (FILE.Existe)
{
using (FileStream EnviarArquivo = new FileStream(FILE.Path, FileMode.Open))
{
long TamanhoArquivoEnviar = EnviarArquivo.Length;
FILE.Lenght = TamanhoArquivoEnviar;
DadosPacote = SerializarPacote(FILE);
BarramentoEscrita.WriteLine(DadosPacote);
BarramentoEscrita.Flush();
byte[] T = new byte[BufferTransmissao];
using (BinaryWriter EVFILE = new BinaryWriter(Brrm))
{
int LoopEnvio = 0;
do
{
int TotalEnviado = EnviarArquivo.Read(T, 0, BufferTransmissao);
EVFILE.Write(T);
LoopEnvio += TotalEnviado;
} while (LoopEnvio <= TamanhoArquivoEnviar);
EnviarArquivo.Close();
}
}
}
else
{
}
break;
default:
P_Error = new Pacote_Error();
P_Error.Error = true;
P_Error.Mensagem = "Esse tipo de pacote não existe.";
P_Error.Tracer = "";
BarramentoEscrita.WriteLine(SerializarPacote(P_Error));
BarramentoEscrita.Flush();
break;
}
}
else
{ //Não existe mecanismo de autenticação.
_Autenticado = new Pacote_Auth {
Autenticado = false,
Error = true,
EMensagem = "O servidor não está configurado com nenhum processo de autenticação."
};
EnviarDadosCliente = SerializarPacote(_Autenticado);
BarramentoEscrita.WriteLine(EnviarDadosCliente);
BarramentoEscrita.Flush();
}
BarramentoLeitura.Close();
BarramentoEscrita.Close();
//Desconectar_Cliente("10.56.34.222","80");
Clients.Close();
}
}
catch (Exception e)
{
TratadorErros(e, this.GetType().Name);;
}
}
