private void threadHandler()
{
// Definição das variáveis networkStream e protocolSI
NetworkStream networkStream = this.client.GetStream();
ProtocolSI protocolSI = new ProtocolSI();
// Ciclo a ser executado até ao fim da transmissão.
while (protocolSI.GetCmdType() != ProtocolSICmdType.EOT)
{
int bytesRead = networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
byte[] ack;
// "Alteração"/mudança entre a apresentação da mensagem e o fim da tranmissão.
switch (protocolSI.GetCmdType())
{
//Dica do ALT
case ProtocolSICmdType.DATA:
Console.WriteLine(clientID + " : " + DateTime.Now.ToShortTimeString() + " " + protocolSI.GetStringFromData());
ack = protocolSI.Make(ProtocolSICmdType.ACK);
networkStream.Write(ack, 0, ack.Length);
break;
case ProtocolSICmdType.EOT:
Console.WriteLine("Ending Thread from Client {0}", clientID);
ack = protocolSI.Make(ProtocolSICmdType.ACK);
networkStream.Write(ack, 0, ack.Length);
break;
}
}
// Fecho do networkStream e do cliente (TcpClient)
networkStream.Close();
client.Close();
}
private void Form1_Load(object sender, EventArgs e)
{
ProtocolSI protocolSI = new ProtocolSI(); //instanciar protocolo de comunicaçao
//instaciar cript assimetrica
string publickeystring = rsa.ToXmlString(false); //buscar chave publica
byte[] publicKeyPacket = protocolSI.Make(ProtocolSICmdType.PUBLIC_KEY, publickeystring);
networkStream.Write(publicKeyPacket, 0, publicKeyPacket.Length); //mandar chave publica para servidor
while (protocolSI.GetCmdType() != ProtocolSICmdType.SECRET_KEY) //receber chave simetrica e desencriptar
{
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
byte[] simetrickeypacket = protocolSI.GetData();
byte[] decryptedkey = rsa.Decrypt(simetrickeypacket, true);
aes.Key = decryptedkey;
//comfirmar receçao
byte[] keycomfirmreceived = protocolSI.Make(ProtocolSICmdType.DATA, "true");
networkStream.Write(keycomfirmreceived, 0, keycomfirmreceived.Length);
}
while (protocolSI.GetCmdType() != ProtocolSICmdType.IV) //receber IV e desencriptar
{
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
byte[] IVpacket = protocolSI.GetData();
byte[] decryptedIV = rsa.Decrypt(IVpacket, true);
aes.IV = decryptedIV;
//comfirmarrececao
byte[] IVcomfirmreceived = protocolSI.Make(ProtocolSICmdType.DATA, "true");
networkStream.Write(IVcomfirmreceived, 0, IVcomfirmreceived.Length);
}
}
public static bool LerRespostaServidor() // apenas ACK ou NACK
{
bool resposta = false;
try
{
//le da stream
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
// VERIFICA O TIPO DE MENSAGEM (DO SERVIDOR)
switch (protocolSI.GetCmdType())
{
// SE FOR DO TIPO ACK É PORQUE está tudo válido
// e se for NACK algo está inválido
case ProtocolSICmdType.NACK:
resposta = false;
break;
case ProtocolSICmdType.ACK:
resposta = true;
break;
}
}
catch (SocketException)
{
MessageBox.Show("Não foi possivel conectar ao servidor");
return(resposta);
}
return(resposta);
}
private void Enviar_Click(object sender, EventArgs e)
{
string msg = "";
byte[] userData = protocolSI.Make(ProtocolSICmdType.DATA, textBoxMensagem.Text);
networkStream.Write(userData, 0, userData.Length);
while (true)
{
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
if (protocolSI.GetCmdType() == ProtocolSICmdType.ACK)
{
break;
}
else if (protocolSI.GetCmdType() == ProtocolSICmdType.DATA)
{
msg = msg + protocolSI.GetStringFromData();
}
}
listBoxChat.Items.Insert(0, $"Cliente: {textBoxMensagem.Text}");
textBoxMensagem.Clear();
textBoxMensagem.Enabled = true;
if (!String.IsNullOrWhiteSpace(msg))
{
listBoxChat.Items.Insert(0, $"Server: {msg}");
}
}
private void threadHandler()
{
NetworkStream networkStream = this.client.GetStream();
ProtocolSI protocolSI = new ProtocolSI();
while (protocolSI.GetCmdType() != ProtocolSICmdType.EOT)
{
int bytesRead = networkStream.Read(protocolSI.Buffer, 0,
protocolSI.Buffer.Length);
byte[] ack;
switch (protocolSI.GetCmdType())
{
case ProtocolSICmdType.DATA:
Console.WriteLine("Client " + clientID + ":" + protocolSI.GetStringFromData());
ack = protocolSI.Make(ProtocolSICmdType.ACK);
networkStream.Write(ack, 0, ack.Length);
break;
case ProtocolSICmdType.EOT:
Console.WriteLine("Client {0} has disconnected", clientID);
ack = protocolSI.Make(ProtocolSICmdType.ACK);
networkStream.Write(ack, 0, ack.Length);
break;
}
}
networkStream.Close();
client.Close();
}
static void Main(string[] args)
{
TcpListener tcpl = null;
TcpClient tcpc = null;
NetworkStream stream = null;
try
{
tcpl = new TcpListener(IPAddress.Any, 9999);
tcpl.Start();
Console.Write("Waiting for client... ");
tcpc = tcpl.AcceptTcpClient();
Console.WriteLine("ok");
stream = tcpc.GetStream();
ProtocolSI protocol = new ProtocolSI();
ProtocolSICmdType command;
byte[] packet;
do
{
stream.Read(protocol.Buffer, 0, protocol.Buffer.Length);
command = protocol.GetCmdType();
switch (protocol.GetCmdType())
{
case ProtocolSICmdType.NORMAL:
Console.WriteLine("inteiro: " + protocol.GetIntFromData().ToString());
break;
case ProtocolSICmdType.DATA:
Console.WriteLine("string: " + protocol.GetStringFromData());
break;
case ProtocolSICmdType.EOT:
Console.WriteLine("end");
break;
default:
Console.WriteLine("not expected");
break;
}
} while (command != ProtocolSICmdType.EOT);
packet = protocol.Make(ProtocolSICmdType.ACK);
stream.Write(packet, 0, packet.Length);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
throw;
}
finally
{
Console.WriteLine("disconnected");
if (stream != null) stream.Dispose();
if (tcpc != null) tcpc.Close();
if (tcpl != null) tcpl.Stop();
}
}
private void btnEnviarMensagem_Click(object sender, EventArgs e)
{
string msg = tbEnviarmensagem.Text;
tbEnviarmensagem.Clear();
byte[] packet = protocolSI.Make(ProtocolSICmdType.DATA, msg);
networkStream.Write(packet, 0, packet.Length);
while (protocolSI.GetCmdType() != ProtocolSICmdType.ACK)
{
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
}
}
private void Form1_Load(object sender, EventArgs e)
{
protocolSI = new ProtocolSI();
try
{
aes = new AesCryptoServiceProvider();
rsa = new RSACryptoServiceProvider();
tcpClient = new TcpClient();
IPEndPoint endPoint = new IPEndPoint(IPAddress.Loopback, PORT);
MessageBox.Show("Connecting...");
tcpClient.Connect(endPoint);
MessageBox.Show("Connected to Server");
networkStream = tcpClient.GetStream();
// DÁ A PUBLIC KEY DO SERVIDOR PARA VERIFICAR SE A LIGAÇÃO ESTÁ SEGURA
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
if (protocolSI.GetCmdType() == ProtocolSICmdType.PUBLIC_KEY)
{
rsa.FromXmlString(protocolSI.GetStringFromData()); //
byte[] secretKey = protocolSI.Make(ProtocolSICmdType.SECRET_KEY, rsa.Encrypt(aes.Key, true));
networkStream.Write(secretKey, 0, secretKey.Length);
//Receive ack
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
if (protocolSI.GetCmdType() != ProtocolSICmdType.ACK)
{
MessageBox.Show("Erro!");
}
secretKey = protocolSI.Make(ProtocolSICmdType.IV, rsa.Encrypt(aes.IV, true));
networkStream.Write(secretKey, 0, secretKey.Length);
//Receive ack
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
if (protocolSI.GetCmdType() != ProtocolSICmdType.ACK)
{
MessageBox.Show("Erro!");
}
}
}
catch (Exception)
{
throw;
}
}
private bool Receber_ACK()
{
int bytesRead = networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
// VERIFICA O TIPO DE MENSAGEM RECEBIDO
if (protocolSI.GetCmdType() == ProtocolSICmdType.ACK)
{
return(true);
}
else
{
return(false);
}
}
private void EnviarMensagem(string msg)
{
byte[] chat = protocolSI.Make(ProtocolSICmdType.DATA, msg); //cria uma mensagem/pacote de um tipo específico
networkStream.Write(chat, 0, chat.Length);
while (protocolSI.GetCmdType() != ProtocolSICmdType.ACK)
{
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
}
}
public bool esperaACK() //Espera o ACK do cliente
{
networkStream.ReadTimeout = 100;
try
{
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
while (protocolSI.GetCmdType() != ProtocolSICmdType.ACK)
{
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
}
networkStream.ReadTimeout = -1;
return(true);
}
catch (IOException)
{
networkStream.ReadTimeout = -1;
return(false);
}
}
private void btnLogin_Click(object sender, EventArgs e)
{
byte[] login = protocolSI.Make(ProtocolSICmdType.USER_OPTION_5, encrypt_symmetric(Encoding.UTF8.GetBytes(txtUsername.Text)));
networkStream.Write(login, 0, login.Length);
//Receive ack
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
if (protocolSI.GetCmdType() != ProtocolSICmdType.ACK)
{
MessageBox.Show("Erro!");
}
login = protocolSI.Make(ProtocolSICmdType.USER_OPTION_5, encrypt_symmetric(Encoding.UTF8.GetBytes(txtPassword.Text)));
networkStream.Write(login, 0, login.Length);
//Receive ack
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
if (protocolSI.GetCmdType() != ProtocolSICmdType.ACK)
{
MessageBox.Show("Erro!");
}
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
string resposta = protocolSI.GetStringFromData();
if (resposta == "True")
{
this.BeginInvoke((Action) delegate
{
NovoMenu();
});
}
else
{
MessageBox.Show("Invalid User");
}
}
private void MensagemDeEntrada()
{
//mensagem escrita que será enviada para o servidor
string msg = DateTime.Now + "\r\n" + User + " Entrou No Servidor" + "\r\n";
//Criar a mensagem
byte[] packet = protocolSI.Make(ProtocolSICmdType.DATA, msg);
//Enviar a mensagem pela ligação
try
{
networkStream.Write(packet, 0, packet.Length);
}
catch (Exception ex)
{
}
while (protocolSI.GetCmdType() != ProtocolSICmdType.ACK)
{
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
}
}
public static void sendFile(string file)
{
int bytesread = 0;
int buffersize = 1024;
byte[] buffer = new byte[buffersize];
byte[] packet;
byte[] mensagenzinha;
string originalFilePath = Path.Combine(Environment.CurrentDirectory, @"Files\");
FileStream originalFileStream = new FileStream(originalFilePath + file, FileMode.Open);
/**/
byte[] fullimage = new byte[originalFileStream.Length];
byte[] signature = null;
using (SHA512 sha = SHA512.Create())
{
signature = rsa.SignData(fullimage, CryptoConfig.MapNameToOID("SHA512"));
}
byte[] signPack = protocolSI.Make(ProtocolSICmdType.DIGITAL_SIGNATURE, signature);
networkStream.Write(signPack, 0, signPack.Length);
/**/
while ((bytesread = originalFileStream.Read(buffer, 0, buffersize)) > 0)
{
//originalFileStream.Read(buffer, 0, bytesread);
buffer = protocolSI.Make(ProtocolSICmdType.USER_OPTION_8, buffer);
networkStream.Write(buffer, 0, buffer.Length);
//send ack
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
if (protocolSI.GetCmdType() != ProtocolSICmdType.ACK)
{
break;
}
}
mensagenzinha = protocolSI.Make(ProtocolSICmdType.EOF);
networkStream.Write(mensagenzinha, 0, mensagenzinha.Length);
originalFileStream.Close();
}
private void btnListaFicheiros_Click(object sender, EventArgs e)
{
ProtocolSI protocolSI = new ProtocolSI(); //instanciar protocolo de comunicaçao
byte[] getfiles = protocolSI.Make(ProtocolSICmdType.USER_OPTION_3);
networkStream.Write(getfiles, 0, getfiles.Length); //enviar pedido
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
if (protocolSI.GetStringFromData() == "true")// comfirmar permissao de acesso
{
bool filesreceived = false;
while (filesreceived == false)
{
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length); //receber lista
if (protocolSI.GetCmdType() == ProtocolSICmdType.DATA)
{
byte[] bytes = bytedecrypter(protocolSI.GetData());
string ficheiros = Encoding.UTF8.GetString(bytes);
listBoxListaFicheiros.Items.Clear();
foreach (var item in ficheiros.Split('|'))
{
listBoxListaFicheiros.Items.Add(item);
}
filesreceived = true;
}
}
}
else
{
MessageBox.Show("Acess not granted", "Send Files",
MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
private void tbLogin_Click(object sender, EventArgs e)
{
//Prepara o envio dos dados de login
string login = tbUsuario.Text;
string senha = tbSenha.Text;
byte[] pctLogin = protocolSI.Make(ProtocolSICmdType.USER_OPTION_1, protocolSecurity.cifrarMensagem(login));
byte[] pctSenha = protocolSI.Make(ProtocolSICmdType.SECRET_KEY, protocolSecurity.cifrarMensagem(senha));
//Envia o login
networkStream.Write(pctLogin, 0, pctLogin.Length);
esperaACK();
//Envia a senha
networkStream.Write(pctSenha, 0, pctSenha.Length);
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
while (protocolSI.GetCmdType() != ProtocolSICmdType.ACK)
{
if (protocolSI.GetCmdType() == ProtocolSICmdType.USER_OPTION_3)
{
MessageBox.Show("Senha incorreta!");
enviaACK();
return;
}
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
}
lastMsg = protocolSecurity.decifrarMensagem(protocolSI.GetStringFromData());
string[] msg = lastMsg.Split('/');;
tbJogadores.Text = msg[0];
tbPontos.Text = msg[1];
btConectar.Enabled = true;
tbSala.Enabled = true;
btSair.Enabled = true;
tbUsuario.Enabled = false;
tbSenha.Enabled = false;
btEntrar.Enabled = false;
enviaACK();
}
public Form_Autenticar()
{
InitializeComponent();
//PARA A ENCRIPATAÇÃO
aes = new AesCryptoServiceProvider();
//PARA A HASH PARA VALIDAÇÃO DE DADOS (INTEGRIDADE)
sha512 = SHA512.Create();
//INICIA O CLIENTE TCP
endpoint = new IPEndPoint(IPAddress.Loopback, ipPort);
tcpClient = new TcpClient();
try
{
//LIGA-SE AO SERVIDOR
tcpClient.Connect(endpoint);
//OBTEM A STREAM DE COMUNICAÇÃO
networkStream = tcpClient.GetStream();
//INICIA O PROTOCOLO SI PARA TRATAR DAS MENSAGENS
protocolSI = new ProtocolSI();
//CRIAR AS CHAVES
rSA = new RSACryptoServiceProvider();
//GUARDAR AS CHAVES
publickey = rSA.ToXmlString(false); //Chave Pública
bothkeys = rSA.ToXmlString(true); // Chave Privada + Pública
//1 - CONVERTER OS DADOS PARA BYTE[]
byte[] chavePublica = Encoding.UTF8.GetBytes(publickey);
//ENVIAR PARA O SERVIDOR
if (EnviarChaveServidor(ProtocolSICmdType.USER_OPTION_1, chavePublica) == 1)
{
int i;
for (i = 1; i <= 3; i++)
{
//esperar pela chave simetrica
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
switch (protocolSI.GetCmdType())
{
case ProtocolSICmdType.SECRET_KEY:
//receber chave simetrica
aes.Key = rSA.Decrypt(protocolSI.GetData(), true);
Enviar_ACK();
break;
case ProtocolSICmdType.IV:
//receber vetor da chave simetrica
aes.IV = rSA.Decrypt(protocolSI.GetData(), true);
Enviar_ACK();
break;
case ProtocolSICmdType.SYM_CIPHER_DATA:
// receber a publica do servidor cifrada
byte[] chavePublicaServidorEncriptada = protocolSI.GetData();
//decifrar chave publica
chavePublicaServidor = emString(decifrarComChaveSimetrica(chavePublicaServidorEncriptada));
Enviar_ACK();
break;
case ProtocolSICmdType.NACK:
MessageBox.Show("Ocorreu um erro. Por favor reinicie a aplicação! ");
break;
}
}
}
else
{
MessageBox.Show("Não foi possivel conectar ao servidor. Tente outra vez! ");
return;
}
}
catch (SocketException)
{
MessageBox.Show("Não foi possivel conectar ao servidor. Tente outra vez! ");
return;
}
}
static void Main(string[] args)
{
TcpClient tcpc = null;
NetworkStream stream = null;
TripleDESCryptoServiceProvider crypto = null;
SymmetricsSI symmetrics = null;
try
{
Console.Write("A ligar ao servidor... ");
tcpc = new TcpClient();
tcpc.Connect("", 9999);
Console.WriteLine("ok");
stream = tcpc.GetStream();
ProtocolSI protocol = new ProtocolSI();
byte[] packet;
crypto = new TripleDESCryptoServiceProvider();
symmetrics = new SymmetricsSI(crypto);
// Send key
packet = protocol.Make(ProtocolSICmdType.PADDING, (int)crypto.Padding);
stream.Write(packet, 0, packet.Length);
stream.Read(protocol.Buffer, 0, protocol.Buffer.Length);
packet = protocol.Make(ProtocolSICmdType.IV, crypto.IV);
stream.Write(packet, 0, packet.Length);
stream.Read(protocol.Buffer, 0, protocol.Buffer.Length);
packet = protocol.Make(ProtocolSICmdType.MODE, (int)crypto.Mode);
stream.Write(packet, 0, packet.Length);
stream.Read(protocol.Buffer, 0, protocol.Buffer.Length);
packet = protocol.Make(ProtocolSICmdType.SECRET_KEY, crypto.Key);
stream.Write(packet, 0, packet.Length);
stream.Read(protocol.Buffer, 0, protocol.Buffer.Length);
packet = protocol.Make(ProtocolSICmdType.EOF);
stream.Write(packet, 0, packet.Length);
stream.Read(protocol.Buffer, 0, protocol.Buffer.Length);
var message = symmetrics.Encrypt(Encoding.UTF8.GetBytes("HelloWorld"));
packet = protocol.Make(ProtocolSICmdType.SYM_CIPHER_DATA, message);
stream.Write(packet, 0, packet.Length);
stream.Read(protocol.Buffer, 0, protocol.Buffer.Length);
if (protocol.GetCmdType() != ProtocolSICmdType.ACK)
throw new Exception("Server could not decrypt");
}
catch (Exception e)
{
Console.WriteLine(e.Message);
throw;
}
finally
{
Console.WriteLine("disconnected");
if (stream != null) stream.Dispose();
if (tcpc != null) tcpc.Close();
if (crypto != null) crypto.Dispose();
if (symmetrics != null) crypto.Dispose();
}
}
private static void ServerLogin()
{
byte[] usernameClientEncriptado = null;
byte[] passwordHashEncriptada = null;
byte[] usernameClientBytes = null;
byte[] passwordHashBytes = null;
string usernameClient = null;
string passwordHash = null;
byte[] bytesFeedback = null;
string mensagemFeedback = null;
byte[] mensagemFeedbackBytes = null;
byte[] secretkey = null;
byte[] iv = null;
byte[] ack = null;
ProtocolSICmdType protocolTipoRespostaSecretKey;
ProtocolSICmdType protocolTipoRespostaIV;
//----------------
string key = null;
byte[] keyBytes = null;
//----------------
try
{
do
{
//o outro inicia o processo, estabelece a ligação com o cliente do outro lado se houver pedidos, se não houver fica parado, à espera.
tcpClient = tcpListener.AcceptTcpClient();
//aceita o pedido pendente, e devolve o tcpClient, que é, é informação sobre o cliente que está do outro lado.
//escreve a mensagem de sucesso de ligação.
Console.WriteLine("Connection Successful!");
//networkstream --> canal de comunicação.
//o tcpClient,GetStream() -> Vai buscar a networkstream criada pelo cliente.
networkStream = tcpClient.GetStream();
//diz que já pode mandar mensagens, que está preparado.
Console.WriteLine("Waiting for message ...");
key = servicoAssinaturas.ObterPublicKey();
//string --> vai ao objeto servicoAssinaturas do tipo ServiceCriptoAssimetrica, para obter a public key.
keyBytes = protocolSI.Make(ProtocolSICmdType.PUBLIC_KEY, key);
//vai fazer um buffer do tipo public key, com a public key recebida anteriormente.
networkStream.Write(keyBytes, 0, keyBytes.Length);
//vai enviar uma mensagem para o cliente, com o buffer da public key.
//o cliente vai receber do seu lado, a public key. linha 99
Console.WriteLine("Public Key Shared");
do
{
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
//lê para o buffer a key, enviada anteriormente pelo servidor.
protocolTipoRespostaSecretKey = protocolSI.GetCmdType();
if (protocolTipoRespostaSecretKey == ProtocolSICmdType.SECRET_KEY)
{
secretkey = servicoAssinaturas.DecriptarDados(protocolSI.GetData());
Console.WriteLine("Received Secret Key");
ack = protocolSI.Make(ProtocolSICmdType.ACK);
networkStream.Write(ack, 0, ack.Length);
Console.WriteLine("Acknowlegment (ACK) Sent");
do
{
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
protocolTipoRespostaIV = protocolSI.GetCmdType();
if (protocolTipoRespostaIV == ProtocolSICmdType.IV)
{
iv = servicoAssinaturas.DecriptarDados(protocolSI.GetData());
Console.WriteLine("Received IV");
servicoCriptografiaSimetrica = new ServiceCriptoSimetrica(secretkey, iv);
}
}while (protocolTipoRespostaIV != ProtocolSICmdType.IV);
}
}while (protocolTipoRespostaSecretKey != ProtocolSICmdType.SECRET_KEY);
do
{
//sempre que existe um write do lado do cliente, o código vai para a parte do servidor e efetua a leitura.
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
//vai arranjar a string do array de bytes dos dados que ele recebeu do buffer.
usernameClientEncriptado = protocolSI.GetData();
usernameClientBytes = servicoCriptografiaSimetrica.DecryptDados(usernameClientEncriptado);
usernameClient = Encoding.UTF8.GetString(usernameClientBytes);
//Envia mensagem cmd,a dizer que o username foi recebido.
Console.WriteLine("Client Login Attempt -> " + usernameClient);
//Vai a ler a password no buffer do protocol SI.
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
//vai arranjar um array de bytes com a password, através do buffer recebido.
passwordHashEncriptada = protocolSI.GetData();
passwordHashBytes = servicoCriptografiaSimetrica.DecryptDados(passwordHashEncriptada);
passwordHash = Encoding.UTF8.GetString(passwordHashBytes);
/*Console.WriteLine("Client Password Hash Received -> " + passwordHash);*/
//Escreve a dizer que recebeu a palavra-passe.
//inicia a parte da base de dados. Onde vai verificar o username e a hash da password.
//Database
connect = new SqlConnection();
connect.ConnectionString = Properties.Settings.Default.connectionString;
connect.Open();
String sql = "SELECT * FROM Users WHERE Username = @username";
SqlCommand cmd = new SqlCommand();
cmd.CommandText = sql;
//o parâmetro serve para evitar o sql injection.
//adiciona o parâmetro ao comando sql
//Igual a connection do comando à Connection de cima para saber para onde deverá enviar a query.
//vai fazerum reader para leitura dos dados obtidos pela execução da query.*/
SqlParameter param = new SqlParameter("@username", usernameClient);
cmd.Parameters.Add(param);
cmd.Connection = connect;
SqlDataReader reader = cmd.ExecuteReader();
if (reader.HasRows)
{
//se o utilizador for válido vai obter as passwords e a hash e tudo, os diversos resultados da query.
// devolve o salt que vai ser utilizado para fazer salted hash a password introduzida pelo cliente ao inciar sessão.
//gerar a saltedhash, recorrendo a hash devolvida e à password inserida.
//fecha a conexão da base de dados.
reader.Read();
byte[] saltedPasswordHashStored = (byte[])reader["Password"];
byte[] saltStored = (byte[])reader["Salt"];
byte[] saltedhash = GenerateSaltedHash(Encoding.UTF8.GetBytes(passwordHash), saltStored);
connect.Close();
//Verifica se a saltedhash gerada é igual a saltedhash registada na base de dados
if (saltedhash.SequenceEqual(saltedPasswordHashStored))
{
//se for igual inicializa o a mensagemfeedback = successful
//vai transformar a string num buffer para enviar para a network stream.
//enviar a mensagem, o buffer que contem o feedback do login.
//ao escrever vai para o cliente, que estava À espera de receber um feedback sobre o login.
//o cliente estava parado, agora continua com o server de forma síncrona.
//mensagem a dizer o feedback.
mensagemFeedback = "SUCCESSFUL";
mensagemFeedbackBytes = Encoding.UTF8.GetBytes(mensagemFeedback);
bytesFeedback = protocolSI.Make(ProtocolSICmdType.DATA, servicoCriptografiaSimetrica.EncryptDados(mensagemFeedbackBytes, mensagemFeedbackBytes.Length));
networkStream.Write(bytesFeedback, 0, bytesFeedback.Length);
Console.WriteLine("Login Attempt -> " + mensagemFeedback);
}
else
{
//se as hash's forem diferentes o feedback fica com erro.
//cria um array de bytes, do tipo data, contendo o feedback da mensagem.
//O servidor vai enviar através da networkStream(canal de comunicação), o feedback de erro/insucesso na tentativa de login
//escreve na consola, que ocorreu um erro na tentativa de login.
mensagemFeedback = "FAILED";
mensagemFeedbackBytes = Encoding.UTF8.GetBytes(mensagemFeedback);
bytesFeedback = protocolSI.Make(ProtocolSICmdType.DATA, servicoCriptografiaSimetrica.EncryptDados(mensagemFeedbackBytes, mensagemFeedbackBytes.Length));
networkStream.Write(bytesFeedback, 0, bytesFeedback.Length);
Console.WriteLine("Login Attempt -> " + mensagemFeedback);
}
//--------
}
else
{
//se as hash's forem diferentes o feedback fica com erro.
//cria um array de bytes, do tipo data, contendo o feedback da mensagem.
//O servidor vai enviar através da networkStream(canal de comunicação), o feedback de erro/insucesso na tentativa de login
//escreve na consola, que ocorreu um erro na tentativa de login.
mensagemFeedback = "FAILED";
mensagemFeedbackBytes = Encoding.UTF8.GetBytes(mensagemFeedback);
bytesFeedback = protocolSI.Make(ProtocolSICmdType.DATA, servicoCriptografiaSimetrica.EncryptDados(mensagemFeedbackBytes, mensagemFeedbackBytes.Length));
networkStream.Write(bytesFeedback, 0, bytesFeedback.Length);
Console.WriteLine("Login Attempt -> " + mensagemFeedback);
}
}while (mensagemFeedback != "SUCCESSFUL");
//faz enquanto não for bem sucedido.
}while (mensagemFeedback != "SUCCESSFUL");
//faz enquanto não for bem sucedido.
}
//Para o caso de ocorrerem excepções.
//Chama o procedimento StopServer() e fecha as ligações que estiverem abertas.
catch (Exception)
{
//throw;
StopServer();
}
}
public Form1()
{
InitializeComponent();
this.Width = 670;
//Desabilita os botões que não possuem funcionalidade de imediato
btConectar.Enabled = false;
btMensagem.Enabled = false;
btSair.Enabled = false;
tbMensagem.Enabled = false;
tbSala.Enabled = false;
btTrocarPosicao.Enabled = false;
btVarJogadores.Enabled = false;
tbProxJogador.Enabled = false;
buttons = new List <Button>();
buttons.Add(bt00); buttons.Add(bt01); buttons.Add(bt02);
buttons.Add(bt10); buttons.Add(bt11); buttons.Add(bt12);
buttons.Add(bt20); buttons.Add(bt21); buttons.Add(bt22);
setButtons(false);
//Inicializa o background que é responsável por ficar a escuta do servidor
BackgroundWorker backgroundWorker1 = new BackgroundWorker();
backgroundWorker1.DoWork += new DoWorkEventHandler(backgroundWorker1_DoWork);
backgroundWorker1.RunWorkerCompleted += new RunWorkerCompletedEventHandler(backgroundWorker1_RunWorkerCompleted);
IPEndPoint endPoint = new IPEndPoint(IPAddress.Loopback, PORT);
tcpClient = new TcpClient();
tcpClient.Connect(endPoint);
//Obtem um fluxo para leitura e escrita.
networkStream = tcpClient.GetStream();
//Preparação da comunidade utilizando a classe desenvolvida pelo SI
protocolSI = new ProtocolSI();
//Cria a classe segura que contém as chaves públicas e privada
protocolSecurity = new securityData();
//Prepara o envio da chave pública
byte[] pctPublicKey = protocolSI.Make(ProtocolSICmdType.PUBLIC_KEY, protocolSecurity.getChavePublica());
//Envia a chave pública
networkStream.Write(pctPublicKey, 0, pctPublicKey.Length);
esperaACK();
//Espera a chave simétrica
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
while (protocolSI.GetCmdType() != ProtocolSICmdType.SYM_CIPHER_DATA)
{
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
}
enviaACK();
protocolSecurity.setChaveSimetrica(protocolSI.GetStringFromData());
//Espera o IV
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
while (protocolSI.GetCmdType() != ProtocolSICmdType.IV)
{
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
}
enviaACK();
protocolSecurity.setIV(protocolSI.GetStringFromData());
}
private void btnPedirFicheiro_Click(object sender, EventArgs e)
{
byte[] mensagem = protocolSI.Make(ProtocolSICmdType.DATA, "file");
networkStream.Write(mensagem, 0, mensagem.Length);
String imagem1 = listViewFicheiros.SelectedItems[0].Text;
byte[] mensagemFicheiro = protocolSI.Make(ProtocolSICmdType.DATA, imagem1);
networkStream.Write(mensagemFicheiro, 0, mensagemFicheiro.Length);
int bytesread = 0;
int buffersize = 1024;
byte[] packet;
string copiaFilePath = Path.Combine(Environment.CurrentDirectory, @"Files\");
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
byte[] signature = null;
if (protocolSI.GetCmdType() == ProtocolSICmdType.DIGITAL_SIGNATURE)
{
signature = protocolSI.GetData();
}
using (FileStream copiaFileStream = new FileStream(copiaFilePath + imagem1, FileMode.CreateNew, FileAccess.ReadWrite))
{
do
{
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
if (protocolSI.GetCmdType() == ProtocolSICmdType.USER_OPTION_8)
{
copiaFileStream.Write(protocolSI.GetData(), 0, protocolSI.GetData().Length);
//Enviar ack
packet = protocolSI.Make(ProtocolSICmdType.ACK);
networkStream.Write(packet, 0, packet.Length);
}
} while (protocolSI.GetCmdType() != ProtocolSICmdType.EOF);
copiaFileStream.Seek(0, SeekOrigin.Begin);
byte[] fullimage = new byte[copiaFileStream.Length];
copiaFileStream.Read(fullimage, 0, fullimage.Length);
bool r;
using (SHA512 sha = SHA512.Create())
{
r = rsa.VerifyData(fullimage, sha, signature);
}
if (r)
{
MessageBox.Show("Mensagem corrompida");
}
}
if (imagem1 != null)
{
string copyFilePath = pbxFoto.ImageLocation = Path.Combine(Environment.CurrentDirectory, @"Files\" + imagem1);
/*packet = protocolSI.Make(ProtocolSICmdType.USER_OPTION_1, imagem1);
* networkStream.Write(packet, 0, packet.Length);*/
MessageBox.Show("copiar");
}
// FileStream CopyFileStream = new FileStream(copyFilePath, FileMode.CreateNew);
//CopyFileStream.Write()
//// originalFileStream.Close();
// CopyFileStream.Close();
MessageBox.Show("Copiado com sucesso!");
}
static void Main(string[] args)
{
Console.WriteLine(" == SERVER == ");
Console.Title = "SERVER";
TcpListener listener = null;
TcpClient client = null;
NetworkStream stream = null;
ProtocolSI protocol = null;
byte[] packet = null;
int bytesRead;
try {
protocol = new ProtocolSI();
listener = new TcpListener(IPAddress.Any, PORT);
listener.Start();
client = listener.AcceptTcpClient();
stream = client.GetStream();
ProtocolSICmdType cmd;
do
{
Console.WriteLine("Waiting for client..");
stream.Read(protocol.Buffer, 0, protocol.Buffer.Length);
cmd = protocol.GetCmdType();
switch (cmd)
{
case ProtocolSICmdType.NORMAL:
Console.WriteLine($"Recebido: {protocol.GetIntFromData()}");
break;
case ProtocolSICmdType.DATA:
Console.WriteLine($"Recebido: {protocol.GetStringFromData()}");
break;
case ProtocolSICmdType.EOT:
Console.WriteLine("Recebido: EOT");
break;
default:
Console.WriteLine("Opção inválida.");
break;
}
packet = protocol.Make(ProtocolSICmdType.ACK);
// enviar o ACK
stream.Write(packet, 0, packet.Length);
Console.WriteLine("ack enviado");
} while (cmd != ProtocolSICmdType.EOT);
Console.WriteLine("Comunicação Terminada. <tecla para terminar>");
} catch (Exception ex) {
Console.WriteLine($"Error: {ex.Message}");
} finally {
if (client != null)
{
client.Dispose();
}
if (stream != null)
{
stream.Dispose();
}
if (listener != null)
{
listener.Stop();
}
}
Console.ReadKey();
}
private void ThreadHandler()
{
networkStream = client.GetStream();
protocolSI = new ProtocolSI();
// Repete ate receber a mensagem de fim de transmissao
while (protocolSI.GetCmdType() != ProtocolSICmdType.EOT)
{
try
{
// Recebe as mensagens do cliente
int bytesRead = networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
}
catch (Exception ex)
{
Console.WriteLine("Erro: " + ex);
return;
}
byte[] ack;
// Verifica o tipo de mensagem
switch (protocolSI.GetCmdType())
{
// Se for uma mensagem do chat
case ProtocolSICmdType.DATA:
{
byte[] msgBytes = null;
try
{
msgBytes = protocolSI.GetData();
}
catch (Exception ex)
{
Console.WriteLine("Erro: " + ex);
return;
}
string msgRecebida = Decifra(msgBytes);
string hash = msgRecebida.Substring(0, msgRecebida.IndexOf(" "));
msgRecebida = msgRecebida.Substring(msgRecebida.IndexOf(" ") + 1);
if (Common.ValidacaoDados(msgRecebida, hash))
{
string msg = user.Username + ": " + msgRecebida;
Console.WriteLine(" Cliente " + msg);
// Guarda os dados no ficheiro
FileHandler.SaveData(currentRoom.ToString(), msg);
try
{
// Envia o ACK para o cliente
ack = protocolSI.Make(ProtocolSICmdType.ACK);
networkStream.Write(ack, 0, ack.Length);
}
catch (Exception ex)
{
Console.WriteLine("Erro: " + ex);
return;
}
}
else
{
Console.WriteLine("Hash não é igual");
}
}
break;
// Se for para fechar a comunicacao
case ProtocolSICmdType.EOT:
{
try
{
// Envia o ACK para o cliente
ack = protocolSI.Make(ProtocolSICmdType.ACK);
networkStream.Write(ack, 0, ack.Length);
}
catch (Exception ex)
{
Console.WriteLine("Erro: " + ex);
return;
}
} break;
// Envia log do chat
case ProtocolSICmdType.USER_OPTION_1:
{
string log = FileHandler.LoadData(currentRoom.ToString());
// Variavel auxiliar
string stringChunk = "";
// Tamanho da resposta
int stringLenght = log.Length;
for (int i = 0; i < log.Length; i = i + CHUNKSIZE)
{
if (CHUNKSIZE > stringLenght)
{
stringChunk = log.Substring(i);
}
else
{
stringLenght = stringLenght - CHUNKSIZE;
stringChunk = log.Substring(i, CHUNKSIZE);
}
// Cifra a mensagem
byte[] msgCifrada = Cifra(stringChunk);
Thread.Sleep(100);
Send(msgCifrada, ProtocolSICmdType.DATA);
}
Thread.Sleep(100);
try
{
// Envia EOF
byte[] eof = protocolSI.Make(ProtocolSICmdType.EOF);
networkStream.Write(eof, 0, eof.Length);
}
catch (Exception ex)
{
Console.WriteLine("Erro: " + ex);
return;
}
} break;
// Troca de chaves
case ProtocolSICmdType.USER_OPTION_2:
{
string pk = "";
try
{
// Recebe a chave publica do cliente
pk = protocolSI.GetStringFromData();
}
catch (Exception ex)
{
Console.WriteLine("Erro: " + ex);
return;
}
string hash = pk.Substring(0, pk.IndexOf(" "));
pk = pk.Substring(pk.IndexOf(" ") + 1);
if (Common.ValidacaoDados(pk, hash))
{
// Cria uma chave simétrica
aes = new AesCryptoServiceProvider();
// Guarda a chave simetrica
key = aes.Key;
iv = aes.IV;
// Cria chave publica do cliente para poder encriptar
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
rsa.FromXmlString(pk);
// Cria um array com as duas keys
byte[] keys = Encoding.UTF8.GetBytes(Convert.ToBase64String(key) + " " + Convert.ToBase64String(iv));
// Encripta a key e o iv
byte[] keyEnc = rsa.Encrypt(keys, true);
Send(keyEnc, ProtocolSICmdType.USER_OPTION_2);
}
else
{
Console.WriteLine("Hash não é igual");
}
} break;
// Login
case ProtocolSICmdType.USER_OPTION_3:
{
// Recebe os dados do cliente
byte[] credenciaisBytes = protocolSI.GetData();
string credenciais = Decifra(credenciaisBytes);
string hash = credenciais.Substring(0, credenciais.IndexOf(" "));
credenciais = credenciais.Substring(credenciais.IndexOf(" ") + 1);
string username = credenciais.Substring(0, credenciais.IndexOf(" "));
string password = credenciais.Substring(credenciais.IndexOf(" ") + 1);
if (Common.ValidacaoDados(username + " " + password, hash))
{
// Verifica se o utilizador existe na base de dados
User utilizador = (from User in spksContainer.Users
where User.Username.Equals(username)
select User).FirstOrDefault();
int state;
// Utilizador nao existe ou nome de utilizador errado
if (utilizador == null)
{
state = 2;
}
// Password errada
else if (utilizador.Password != Common.HashPassword(password, utilizador.Salt))
{
state = 1;
}
// Utilizador existe e passowrd está certa
else
{
user = utilizador;
state = 0;
}
byte[] msgCifrada = Cifra(state.ToString());
Send(msgCifrada, ProtocolSICmdType.USER_OPTION_3);
}
else
{
Console.WriteLine("Hash não é igual");
}
}
break;
// Cria conta
case ProtocolSICmdType.USER_OPTION_4:
{
byte[] credenciaisBytes;
try
{
// Recebe os dados do cliente
credenciaisBytes = protocolSI.GetData();
}
catch (Exception ex)
{
Console.WriteLine("Erro: " + ex);
return;
}
// Decifra e guarda as credenciais
string credenciais = Decifra(credenciaisBytes);
string hash = credenciais.Substring(0, credenciais.IndexOf(" "));
credenciais = credenciais.Substring(credenciais.IndexOf(" ") + 1);
string username = credenciais.Substring(0, credenciais.IndexOf(" "));
string password = credenciais.Substring(credenciais.IndexOf(" ") + 1);
if (Common.ValidacaoDados(username + " " + password, hash))
{
User newUser = new User(username, password);
spksContainer.Users.Add(newUser);
spksContainer.SaveChanges();
Console.WriteLine("Utilizador " + username + " criado");
}
else
{
Console.WriteLine("Hash não é igual");
}
}
break;
// Jogo
case ProtocolSICmdType.USER_OPTION_5:
{
byte[] msgBytes = null;
try
{
msgBytes = protocolSI.GetData();
}
catch (Exception ex)
{
Console.WriteLine("Erro: " + ex);
return;
}
// Decifra e guarda jogada
string jogada = Decifra(msgBytes);
string hash = jogada.Substring(0, jogada.IndexOf(" "));
jogada = jogada.Substring(jogada.IndexOf(" ") + 1);
if (Common.ValidacaoDados(jogada, hash))
{
Console.WriteLine(" Cliente " + user.Username + " jogou: " + jogada);
if (currentRoom.GetPlayer1Name() == user.Username)
{
currentRoom.Player1Play = jogada;
}
else
{
currentRoom.Player2Play = jogada;
}
try
{
// Envia o ACK para o cliente
ack = protocolSI.Make(ProtocolSICmdType.ACK);
networkStream.Write(ack, 0, ack.Length);
}
catch (Exception ex)
{
Console.WriteLine("Erro: " + ex);
return;
}
while (true)
{
if (lastState != currentRoom.GameState)
{
string msg = currentRoom.Player1Pontos.ToString() + " " + currentRoom.Player2Pontos.ToString() + " " + currentRoom.GameState;
// BUG: Inserir breakpoint na linha de baixo para o jogo funcionar
Send(Cifra(msg), ProtocolSICmdType.USER_OPTION_5);
lastState = currentRoom.GameState;
break;
}
}
}
else
{
Console.WriteLine("Hash não é igual");
}
} break;
// Adiciona o jogador a sala
case ProtocolSICmdType.USER_OPTION_6:
{
byte[] msgBytes = null;
try
{
msgBytes = protocolSI.GetData();
}
catch (Exception ex)
{
Console.WriteLine("Erro: " + ex);
return;
}
// Decifra e guarda sala
string sala = Decifra(msgBytes);
string hash = sala.Substring(0, sala.IndexOf(" "));
sala = sala.Substring(sala.IndexOf(" ") + 1);
if (Common.ValidacaoDados(sala, hash))
{
// Verifica existem salas
if (Game.rooms.Count == 0)
{
CriaSala(sala);
}
else
{
try
{
foreach (Room room in Game.rooms)
{
if (room.ToString() == sala)
{
JuntaSala(room);
}
else if (room == Game.rooms.Last() && room.ToString() == sala)
{
JuntaSala(room);
break;
}
else if (room == Game.rooms.Last())
{
CriaSala(sala);
}
}
}
catch (Exception)
{
}
}
}
else
{
Console.WriteLine("Hash não é igual");
}
}
break;
default:
break;
}
}
// Fecha as conecoes
networkStream.Close();
client.Close();
Console.WriteLine("O Cliente {0} desconnectou-se", clientId);
}
private void buttonLoginRegister_Click(object sender, EventArgs e)
{
string msg = ""; // Cria a variável que recebe a resposta do Servidor
if (!String.IsNullOrWhiteSpace(textBoxUsername.Text) || !String.IsNullOrWhiteSpace(textBoxPassword.Text)) // Verifica se os campos de Username e Password estão preenchidos
{
byte[] option1 = protocolSI.Make(ProtocolSICmdType.USER_OPTION_1, textBoxUsername.Text); // Cria a mensagem que envia o Username do utilizador
networkStream.Write(option1, 0, option1.Length); // Envia a mensagem através da Stream
while (protocolSI.GetCmdType() == ProtocolSICmdType.ACK) // Espera pela confirmação (Acknowledge) do Servidor
{
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
}
/* Verifica se é para realizar Login ou Registo */
if (isLogin == true) // Caso seja Login
{
byte[] option3 = protocolSI.Make(ProtocolSICmdType.USER_OPTION_3, textBoxPassword.Text); // Cria a mensagem que envia a Password do utilizador
networkStream.Write(option3, 0, option3.Length); // Envia a mensagem através da Stream
while (true)
{
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length); // Lê o buffer
if (protocolSI.GetCmdType() == ProtocolSICmdType.ACK) // Se for ACK (Acknowledge) sai fora do ciclo While
{
break;
}
else if (protocolSI.GetCmdType() == ProtocolSICmdType.DATA) // Se for DATA apanha a resposta do Servidor
{
msg += protocolSI.GetStringFromData();
}
}
}
else // Caso seja Registo
{
byte[] option2 = protocolSI.Make(ProtocolSICmdType.USER_OPTION_2, textBoxPassword.Text); // Cria a mensagem que envia a Password do utilizador
networkStream.Write(option2, 0, option2.Length); // Envia a mensagem através da Stream
while (true)
{
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length); // Lê o buffer
if (protocolSI.GetCmdType() == ProtocolSICmdType.ACK) // Se for ACK (Acknowledge) sai fora do ciclo While
{
break;
}
else if (protocolSI.GetCmdType() == ProtocolSICmdType.DATA) // Se for DATA apanha a resposta do Servidor
{
msg += protocolSI.GetStringFromData();
}
}
}
if (!String.IsNullOrWhiteSpace(msg)) // Verifica se a resposta do Servidor é vazia ou null
{
MessageBox.Show(msg, "Login/Registo."); // Apresenta a resposta ao utilizador
}
formCliente = new FormCliente(networkStream, protocolSI, tcpClient); // Instancia o Form do CLiente (janela de Chat) com as informações de conexão
this.Hide(); // Esconde a janela de Login (não dá para fechar a janela pois fecharia também a janela de Chat)
formCliente.ShowDialog(); // Abre a janela de Chat
}
else
{
MessageBox.Show("Tem de preencher os campos todos.", "Atenção!", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
public bool Login(string username, string password)
{
string credenciais = username + " " + password;
byte[] msgCifrada = Cifra(credenciais);
// Envia os dados para o servidor
Send(msgCifrada, ProtocolSICmdType.USER_OPTION_3);
try
{
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
int state = -1;
string msg = "";
// Enquanto nao receber um ACK recebe o que o servidor envia
while (protocolSI.GetCmdType() != ProtocolSICmdType.ACK)
{
if (protocolSI.GetCmdType() == ProtocolSICmdType.USER_OPTION_3)
{
byte[] receivedData = protocolSI.GetData();
// Decifra a mensagem
msg = Decifra(receivedData);
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
}
}
string hash = msg.Substring(0, msg.IndexOf(" "));
msg = msg.Substring(msg.IndexOf(" ") + 1);
if (!ValidacaoDados(msg, hash))
{
Console.WriteLine("Hash não é igual");
return(false);
}
state = int.Parse(msg);
switch (state)
{
// Faz login
case 0:
return(true);
// Password errada
case 1:
MessageBox.Show("Password errada");
break;
// Utilizador nao existe ou nome de utilizador errado
case 2:
DialogResult resposta = MessageBox.Show("Deseja criar uma conta nova?", "Conta nao existe", MessageBoxButtons.YesNo);
if (resposta == DialogResult.Yes)
{
// Envia os dados para o servidor
byte[] response = protocolSI.Make(ProtocolSICmdType.USER_OPTION_4, msgCifrada);
networkStream.Write(response, 0, response.Length);
}
break;
default:
break;
}
}
catch (Exception)
{
return(false);
}
return(false);
}
private void btnObterFicheiro_Click(object sender, EventArgs e)
{
try
{
//vai buscar o nome do ficheiro que quer obter e para mandar para o servidor para pedir a imagem.
string fileRequest = lvLista.SelectedItems[0].Text;
//Transforma a string num array de bytes, do tipo dado, e a ação a executar.
byte[] requestListBytes = Encoding.UTF8.GetBytes("GETFILE");
byte[] requestList = protocolSI.Make(ProtocolSICmdType.DATA, servicoCriptoSimetrico.EncryptDados(requestListBytes, requestListBytes.Length));
//escreve na network stream para o servidor.
networkStream.Write(requestList, 0, requestList.Length);
//vai buscar um buffer do tipo data, com o pedido do ficheiro
byte[] fileRequestedBytes = Encoding.UTF8.GetBytes(fileRequest);
byte[] fileRequested = protocolSI.Make(ProtocolSICmdType.DATA, servicoCriptoSimetrico.EncryptDados(fileRequestedBytes, fileRequestedBytes.Length));
//escreve na networkstream o buffer com o nome do ficheiro.
networkStream.Write(fileRequested, 0, fileRequested.Length);
if (File.Exists(fileRequest))
{
File.Delete(fileRequest);
}
//NOVO
byte[] assinaturaBytes = null;
byte[] finalImageHash = null;
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
assinaturaBytes = protocolSI.GetData();
//----------
using (FileStream fileStream = new FileStream(fileRequest, FileMode.CreateNew, FileAccess.ReadWrite))
{
ProtocolSICmdType protocolTipoResposta;
int bytesRead;
byte[] acknowledge;
byte[] imageBuffer;
do
{
bytesRead = networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
protocolTipoResposta = protocolSI.GetCmdType();
if (protocolTipoResposta == ProtocolSICmdType.DATA)
{
//Encriptado
imageBuffer = protocolSI.GetData();
byte[] imageBufferDecriptadoBytes = servicoCriptoSimetrico.DecryptDados(imageBuffer);
string imageBufferDecriptadoString = Encoding.UTF8.GetString(imageBufferDecriptadoBytes);
fileStream.Write(imageBufferDecriptadoBytes, 0, imageBufferDecriptadoBytes.Length);
Debug.Print("Received " + imageBufferDecriptadoBytes.Length + " + " + (bytesRead - imageBufferDecriptadoBytes.Length) + " Bytes");
acknowledge = protocolSI.Make(ProtocolSICmdType.ACK);
//byte[] acknowledgeEncriptado = servicoCriptoSimetrico.EncryptDados(acknowledge, acknowledge.Length);
networkStream.Write(acknowledge, 0, acknowledge.Length);
Debug.Print("Acknowlegment (ACK) Sent");
}
else if (protocolTipoResposta == ProtocolSICmdType.EOF)
{
Debug.Print("Reached End of File (EOF)");
}
}while (protocolTipoResposta != ProtocolSICmdType.EOF);
// NOVO
byte[] file = new byte[fileStream.Length];
fileStream.Seek(0, SeekOrigin.Begin);
fileStream.Read(file, 0, file.Length);
finalImageHash = servicoAssinaturas.HashImagem(file);
//----------
}
//NOVO
if (servicoAssinaturas.VerAssinaturaHash(finalImageHash, assinaturaBytes))
{
lvLista.SelectedItems[0].SubItems[1].Text = "Sim";
btnAbrirFicheiro.Enabled = true;
}
else
{
MessageBox.Show("Dados corrompidos. Descartados", "Erro");
if (File.Exists(fileRequest))
{
File.Delete(fileRequest);
}
}
//----------
}
catch (Exception)
{
MessageBox.Show("Erro encontrado. A encerrar", "Erro", MessageBoxButtons.OK, MessageBoxIcon.Error);
ShutDown();
StopConnection();
//throw;
}
}
private void Form1_Load(object sender, EventArgs e)
{
try
{
//é equivalente à inicialização de objetos e preparação do cliente.
tcpClient = new TcpClient();
endPoint = new IPEndPoint(IPAddress.Loopback, port);
tcpClient.Connect(endPoint);
networkStream = tcpClient.GetStream();
protocolSI = new ProtocolSI();
servicoCriptoSimetrico = new ServiceCriptoSimetrica();
string publickey = null;
byte[] secretkey = null;
byte[] iv = null;
ProtocolSICmdType protocolTipoResposta;
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
//lê para o buffer a key, enviada anteriormente pelo servidor.
if (protocolSI.GetCmdType() == ProtocolSICmdType.PUBLIC_KEY)
{
//serve para determinar e verificar se o buffer é do tipo public key, se for executa.
publickey = protocolSI.GetStringFromData();
//obtêm a string do buffer, este sendo um array de bytes.
//Receção e envio da public key, do cliente para o servidor e receber do servidor
Debug.Print("Received Public Key");
servicoAssinaturas = new ServiceCriptoAssimetrica(publickey);
//Vai instanciar um servico de criptografia assimetrica, com a public key do servidor.
//O construtor desta classe necessita da public key, por isso é que só foi inicializado agora.
secretkey = servicoCriptoSimetrico.ObterSecretKey();
byte[] secretkeyEncriptada = protocolSI.Make(ProtocolSICmdType.SECRET_KEY, servicoAssinaturas.EncriptarDados(secretkey));
networkStream.Write(secretkeyEncriptada, 0, secretkeyEncriptada.Length);
Debug.Print("Secret Key Sent");
do
{
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
protocolTipoResposta = protocolSI.GetCmdType();
if (protocolTipoResposta == ProtocolSICmdType.ACK)
{
iv = servicoCriptoSimetrico.ObterIV();
byte[] ivEncriptado = protocolSI.Make(ProtocolSICmdType.IV, servicoAssinaturas.EncriptarDados(iv));
networkStream.Write(ivEncriptado, 0, ivEncriptado.Length);
Debug.Print("IV Sent");
}
}while (protocolTipoResposta != ProtocolSICmdType.ACK);
//encriptar a chave secreta com a publica envia la ao mesmo tempo
//como o do outro lado.
}
else
{
//caso não seja do tipo public key envia uma mensagem de erro.
MessageBox.Show("Erro ao receber a chave pública", "Atenção", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
catch (Exception)
{
MessageBox.Show("Erro encontrado. A encerrar", "Erro", MessageBoxButtons.OK, MessageBoxIcon.Error);
ShutDown();
StopConnection();
}
}
//----------------obter nomes dos ficheiros numa pasta---------------------
//static string pathFilesFolder = Path.Combine(Environment.CurrentDirectory, @"Files\");
//string[] filesCollection = Directory.GetFiles(pathFilesFolder);
// public static object ProtocolSICmdType { get; private set; }
static void Main(string[] args)
{
aes = new AesCryptoServiceProvider();
protocolSI = new ProtocolSI();
TcpListener tcpListener = null;
TcpClient tcpClient = null;
//NetworkStream networkStream = null;
GenerateKeys();
//try
// {
IPEndPoint endPoint = new IPEndPoint(IPAddress.Loopback, PORT);
tcpListener = new TcpListener(endPoint);
tcpListener.Start();
tcpClient = tcpListener.AcceptTcpClient();
networkStream = tcpClient.GetStream();
//RECEBE A PUBLIC KEY DO CLIENTE
byte[] packet = protocolSI.Make(ProtocolSICmdType.PUBLIC_KEY, chavePublica);
networkStream.Write(packet, 0, packet.Length);
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
if (protocolSI.GetCmdType() == ProtocolSICmdType.SECRET_KEY)
{
aes.Key = rsa.Decrypt(protocolSI.GetData(), true);
}
//send ack
packet = protocolSI.Make(ProtocolSICmdType.ACK);
networkStream.Write(packet, 0, packet.Length);
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
if (protocolSI.GetCmdType() == ProtocolSICmdType.IV)
{
aes.IV = rsa.Decrypt(protocolSI.GetData(), true);
}
//send ack
packet = protocolSI.Make(ProtocolSICmdType.ACK);
networkStream.Write(packet, 0, packet.Length);
//Autenticação
//byte[] login = protocolSI.Make(ProtocolSICmdType.USER_OPTION_5, //encrypt_symmetric("USERNAME"));
//networkStream.Write(login, 0 ,login.Length);
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
login_decrypted = decrypt_symmetric(protocolSI.GetData());
user = Encoding.UTF8.GetString(login_decrypted);
//send ACK
packet = protocolSI.Make(ProtocolSICmdType.ACK);
networkStream.Write(packet, 0, packet.Length);
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
login_decrypted = decrypt_symmetric(protocolSI.GetData());
pass = Encoding.UTF8.GetString(login_decrypted);
//send ACK
packet = protocolSI.Make(ProtocolSICmdType.ACK);
networkStream.Write(packet, 0, packet.Length);
string login_bool = "";
if (VerifyLogin(user, pass))
{
login_bool = "True";
}
else
{
login_bool = "False";
}
packet = protocolSI.Make(ProtocolSICmdType.DATA, login_bool);
networkStream.Write(packet, 0, packet.Length);
int bytesRead = 0;
//############################
int requestListSize;
byte[] bufferRequestList;
requestListSize = tcpClient.ReceiveBufferSize;
bufferRequestList = new byte[requestListSize];
networkStream.Read(bufferRequestList, 0, requestListSize);
byte[] fileList = GetFiles();
networkStream.Write(fileList, 0, fileList.Length);
//*********************************
/*
* networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
* if (protocolSI.GetCmdType() == ProtocolSICmdType.USER_OPTION_1)
* {
* Console.WriteLine(protocolSI.GetStringFromData());
*
* }*/
//*********************************
//############################
//-------------
bool status = true;
do
{
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
if (protocolSI.GetStringFromData() == "file")
{
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
string file = protocolSI.GetStringFromData();
sendFile(file);
}
else if (protocolSI.GetStringFromData() == "shutdown")
{
status = false;
}
} while (status);
if (networkStream != null)
{
networkStream.Close();
}
if (tcpClient != null)
{
tcpClient.Close();
}
if (tcpListener != null)
{
tcpListener.Stop();
}
//------------------------
//Enviar ack
/*Byte[] ack = Encoding.UTF8.GetBytes("OK");
* networkStream.Write(ack, 0, ack.Length);*/
//}
}
static void Main(string[] args)
{
byte[] msg;
IPEndPoint listenEndPoint;
TcpListener server = null;
TcpClient client = null;
NetworkStream netStream = null;
ProtocolSI protocol = null;
AesCryptoServiceProvider aes = null;
SymmetricsSI symmetricsSI = null;
RSACryptoServiceProvider rsaClient = null;
RSACryptoServiceProvider rsaServer = null;
accounts.Add(123, 100.50);
accounts.Add(456, 200.50);
accounts.Add(789, 3000);
try {
Console.WriteLine("SERVER");
#region Defenitions
// algortimos assimétricos
rsaClient = new RSACryptoServiceProvider();
rsaServer = new RSACryptoServiceProvider();
// algoritmos simétrico a usar...
aes = new AesCryptoServiceProvider();
symmetricsSI = new SymmetricsSI(aes);
// Binding IP/port
listenEndPoint = new IPEndPoint(IPAddress.Any, 13000);
// Client/Server Protocol to SI
protocol = new ProtocolSI();
#endregion
Console.WriteLine(SEPARATOR);
#region TCP Listner
// Start TcpListener
server = new TcpListener(listenEndPoint);
server.Start();
// Waits for a client connection (bloqueant wait)
Console.Write("waiting for a connection... ");
client = server.AcceptTcpClient();
netStream = client.GetStream();
Console.WriteLine("ok");
#endregion
Console.WriteLine(SEPARATOR);
#region Exhange Public Keys
// Receive client public key
Console.Write("waiting for client public key...");
netStream.Read(protocol.Buffer, 0, protocol.Buffer.Length);
rsaClient.FromXmlString(protocol.GetStringFromData());
Console.WriteLine("ok");
// Send public key...
Console.Write("Sending public key... ");
msg = protocol.Make(ProtocolSICmdType.PUBLIC_KEY, rsaServer.ToXmlString(false));
netStream.Write(msg, 0, msg.Length);
Console.WriteLine("ok");
#endregion
Console.WriteLine(SEPARATOR);
#region Exchange Secret Key
// Receive key
Console.Write("waiting for key...");
netStream.Read(protocol.Buffer, 0, protocol.Buffer.Length);
aes.Key = rsaServer.Decrypt(protocol.GetData(), true);
Console.WriteLine("ok");
Console.WriteLine(" Received: {0} ", ProtocolSI.ToHexString(aes.Key));
// Answer with a ACK
Console.Write("Sending a ACK... ");
msg = protocol.Make(ProtocolSICmdType.ACK);
netStream.Write(msg, 0, msg.Length);
Console.WriteLine("ok");
// Receive iv
Console.Write("waiting for iv...");
netStream.Read(protocol.Buffer, 0, protocol.Buffer.Length);
aes.IV = rsaServer.Decrypt(protocol.GetData(), true);
Console.WriteLine("ok");
Console.WriteLine(" Received: {0} ", ProtocolSI.ToHexString(aes.IV));
// Answer with a ACK
Console.Write("Sending a ACK... ");
msg = protocol.Make(ProtocolSICmdType.ACK);
netStream.Write(msg, 0, msg.Length);
Console.WriteLine("ok");
#endregion
Console.WriteLine(SEPARATOR);
#region Exchange Data (Secure channel)
// Receive the cipher
Console.Write("waiting for data...");
netStream.Read(protocol.Buffer, 0, protocol.Buffer.Length);
byte[] encryptedData = protocol.GetData();
byte[] data = symmetricsSI.Decrypt(encryptedData);
int account = BitConverter.ToInt32(data, 0);
Console.WriteLine("ok");
Console.WriteLine(" Encrypted: {0}", ProtocolSI.ToHexString(encryptedData));
Console.WriteLine(" Data: {0} = {1}", account, ProtocolSI.ToHexString(data));
// Answer with balance
byte[] clearData = BitConverter.GetBytes(accounts[account]);
Console.Write("Sending data... ");
encryptedData = symmetricsSI.Encrypt(clearData);
msg = protocol.Make(ProtocolSICmdType.DATA, encryptedData);
netStream.Write(msg, 0, msg.Length);
Console.WriteLine("ok");
Console.WriteLine(" Data: {0} = {1}", BitConverter.ToDouble(clearData, 0), ProtocolSI.ToHexString(clearData));
Console.WriteLine(" Encrypted: {0}", ProtocolSI.ToHexString(encryptedData));
#endregion
Console.WriteLine(SEPARATOR);
#region Sending DIGITAL SIGNATURE
Console.Write("waiting... ");
netStream.Read(protocol.Buffer, 0, protocol.Buffer.Length);
Console.WriteLine(protocol.GetCmdType());
Console.Write("Sending digital signature... ");
msg = protocol.Make(ProtocolSICmdType.DIGITAL_SIGNATURE, rsaServer.SignData(encryptedData, new SHA256CryptoServiceProvider()));
netStream.Write(msg, 0, msg.Length);
Console.WriteLine("OK");
//encryptedData[0] = 0;
/*bool status = rsaClient.VerifyData(encryptedData, new SHA256CryptoServiceProvider(), signature);
* Console.WriteLine("OK");
*
* Console.WriteLine("STATUS SIGNATURE = " + status);
*
* Console.Write("Sending (N)ACK...");
*
* if (status) {
* msg = protocol.Make(ProtocolSICmdType.ACK);
* } else {
* msg = protocol.Make(ProtocolSICmdType.NACK);
* }
* netStream.Write(msg, 0, msg.Length);
*
* Console.WriteLine("OK");
*
*
* /*if (status) {
* byte[] data = symmetricsSI.Decrypt(encryptedData);
* Console.WriteLine("ok");
* Console.WriteLine(" Encrypted: {0}", ProtocolSI.ToHexString(encryptedData));
* Console.WriteLine(" Data: {0} = {1}", ProtocolSI.ToString(data), ProtocolSI.ToHexString(data));
* }*/
#endregion
} catch (Exception ex) {
Console.WriteLine(SEPARATOR);
Console.WriteLine("Exception: {0}", ex.ToString());
} finally {
// Close connections
if (netStream != null)
{
netStream.Dispose();
}
if (client != null)
{
client.Close();
}
if (server != null)
{
server.Stop();
}
Console.WriteLine(SEPARATOR);
Console.WriteLine("Connection with client was closed.");
}
Console.WriteLine(SEPARATOR);
Console.Write("End: Press a key...");
Console.ReadKey();
}
static void Main(string[] args)
{
protocolSI = new ProtocolSI();
NetworkStream networkStream = null;
TcpListener tcpListener = null;
TcpClient tcpClient = null;
try {
IPEndPoint endPoint = new IPEndPoint(IPAddress.Loopback, PORT);
tcpListener = new TcpListener(endPoint);
Console.WriteLine("Starting Server... ");
tcpListener.Start();
Console.WriteLine("Waiting for connections...");
tcpClient = tcpListener.AcceptTcpClient();
Console.WriteLine("Client Connected..");
networkStream = tcpClient.GetStream();
int bytesRead = 0;
#region Receive String Message
int bufferSize = tcpClient.ReceiveBufferSize;
//byte[] buffer = new byte[bufferSize];
bytesRead = networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
byte[] packet = protocolSI.GetData();
if (protocolSI.GetCmdType() == = ProtocolSICmdType.DATA)
{
}
Console.WriteLine(Encoding.UTF8.GetString(packet));
// enviar string a dizer ok
byte[] ack = Encoding.UTF8.GetBytes("OK");
networkStream.Write(ack, 0, ack.Length);
#endregion
} catch (Exception) {
throw;
} finally {
if (networkStream != null)
{
networkStream.Close();
}
if (tcpListener != null)
{
tcpListener.Stop();
}
if (tcpClient != null)
{
tcpClient.Close();
}
}
Console.WriteLine("Servidor");
Console.ReadKey();
}
private void registothreadHandler()
{
ProtocolSI protocolSI = new ProtocolSI(); //instanciar protocolo comunicacao
NetworkStream networkStream = client.GetStream();
rsa = new RSACryptoServiceProvider(); //instanciar metodo cryptografico assimetrico
AesCryptoServiceProvider aes = new AesCryptoServiceProvider(); //instanciar metodo cryptografico simetrico
secretkey = aes.Key;
IV = aes.IV;
Console.WriteLine("Recebida uma Nova Ligacao");
LogReg logReg = new LogReg();
bool IsClientLoggedIn = false;
while (protocolSI.GetCmdType() != ProtocolSICmdType.EOT)
{
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
//registar
if (protocolSI.GetCmdType() == ProtocolSICmdType.USER_OPTION_1)
{
string usernamepacket = null;
byte[] salt = null;
byte[] saltypass = null;
usernamepacket = stringdecrypter(protocolSI.GetStringFromData());
Console.WriteLine("Attempt to create a new client: " + usernamepacket);
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
if (protocolSI.GetCmdType() == ProtocolSICmdType.DATA)
{
saltypass = bytedecrypter(protocolSI.GetData());
byte[] comfirmpass = protocolSI.Make(ProtocolSICmdType.DATA, "true");
networkStream.Write(comfirmpass, 0, comfirmpass.Length);
}
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
if (protocolSI.GetCmdType() == ProtocolSICmdType.ACK)
{
salt = bytedecrypter(protocolSI.GetData());
byte[] comfirmsalt = protocolSI.Make(ProtocolSICmdType.DATA, "true");
networkStream.Write(comfirmsalt, 0, comfirmsalt.Length);
}
logReg.Register(usernamepacket, saltypass, salt);
}
//login
if (protocolSI.GetCmdType() == ProtocolSICmdType.USER_OPTION_2)
{
string usernamestring = null;
string pass = null;
usernamestring = stringdecrypter(protocolSI.GetStringFromData());
Console.WriteLine("Tentativa de login de: " + usernamestring);
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
if (protocolSI.GetCmdType() == ProtocolSICmdType.DATA)
{
pass = stringdecrypter(protocolSI.GetStringFromData());
}
IsClientLoggedIn = logReg.VerifyLogin(usernamestring, pass);
byte[] comfirmlogin = protocolSI.Make(ProtocolSICmdType.DATA, IsClientLoggedIn.ToString());
networkStream.Write(comfirmlogin, 0, comfirmlogin.Length);
}
//listaficheiros
if (protocolSI.GetCmdType() == ProtocolSICmdType.USER_OPTION_3)
{
Console.WriteLine("Pedido de envio de lista de ficheiros recebidos");
if (IsClientLoggedIn)
{
byte[] grantaccess = protocolSI.Make(ProtocolSICmdType.USER_OPTION_9, "true");
networkStream.Write(grantaccess, 0, grantaccess.Length);
Console.WriteLine("Pedido aceite, a enviar lista");
DirectoryInfo
dinfo = new DirectoryInfo(
@"C:\Users\joaod\Desktop\ProjectoTopSeg\Recursos"); //diretorio com imagens
FileInfo[] Files = dinfo.GetFiles("."); // get all the files in the directory to the array
string files = "";
foreach (FileInfo file in Files) //guardar nomes dos ficheiros numa string
{
files = files + file.Name + "|";
}
byte[] encriptedfiles = byteencrypter(Encoding.UTF8.GetBytes(files)); //encriptar string
byte[] filespacket = protocolSI.Make(ProtocolSICmdType.DATA, encriptedfiles);
networkStream.Write(filespacket, 0, filespacket.Length); //enviar packet
}
else
{
Console.WriteLine("Pedido negado");
byte[] grantaccess = protocolSI.Make(ProtocolSICmdType.USER_OPTION_9, "false");
networkStream.Write(grantaccess, 0, grantaccess.Length);
}
}
// receber chave publica do cliente
if (protocolSI.GetCmdType() == ProtocolSICmdType.PUBLIC_KEY)
{
string Publickeypacket = protocolSI.GetStringFromData(); //recebe pacote de dados com chave publica cliente
rsa.FromXmlString(Publickeypacket); //importa chave publica
//Buscar key e IV
byte[] key = aes.Key;
byte[] IV = aes.IV;
//encriptar chave simetrica
byte[] encryptedkey = rsa.Encrypt(key, true);
//enviar chave simetrica
byte[] encryptedkeypacket = protocolSI.Make(ProtocolSICmdType.SECRET_KEY, encryptedkey);
networkStream.Write(encryptedkeypacket, 0, encryptedkeypacket.Length);
//aguardar pela resposta
string comfirmationreceivedkey = "idle";
while (comfirmationreceivedkey == "idle")
{
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
comfirmationreceivedkey = protocolSI.GetStringFromData();
}
//encriptar chave simetrica
byte[] encrypedIV = rsa.Encrypt(IV, true);
//enviar IV
byte[] IVpacket = protocolSI.Make(ProtocolSICmdType.IV, encrypedIV);
networkStream.Write(IVpacket, 0, IVpacket.Length);
//aguardar pela resposta
string comfirmationreceivedIV = "idle";
while (comfirmationreceivedIV == "idle")
{
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
comfirmationreceivedIV = protocolSI.GetStringFromData();
}
if (comfirmationreceivedIV == "true" && comfirmationreceivedkey == "true")
{
Console.WriteLine("Parametros de comunicaçao recebidos pelo utilizador");
}
}
//receber ficheiros
if (protocolSI.GetCmdType() == ProtocolSICmdType.USER_OPTION_4)
{
Console.WriteLine("Pedido de envio de ficheiros recebido");
if (IsClientLoggedIn)
{
byte[] grantaccess = protocolSI.Make(ProtocolSICmdType.USER_OPTION_9, "true");
networkStream.Write(grantaccess, 0, grantaccess.Length);
Console.WriteLine("Pedido de envio de ficheiros concebido");
int bytesread = 0;
byte[] signature = null;
byte[] datahash = null;
String copyFilePath = "C:\\Users\\joaod\\Desktop\\ProjectoTopSeg\\Recursos\\copyedfile";
if (File.Exists(copyFilePath)) //verificar se o ficheiro ja existe
{
File.Delete(copyFilePath); //se sim eliminar
}
int tamanhoficheiro = protocolSI.GetIntFromData();
byte[] segment = new byte[tamanhoficheiro];
Console.WriteLine("A receber ficheiro de um cliente");
FileStream copyFileStream = new FileStream(copyFilePath, FileMode.Create);//instanciar controlador de leitura Stream
bool signaturereceived = false;
bool hashreceived = false;
while (signaturereceived == false || hashreceived == false)
{
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
if (protocolSI.GetCmdType() == ProtocolSICmdType.DIGITAL_SIGNATURE) // nao envia assinatura
{
signature = bytedecrypter(protocolSI.GetData());
byte[] bytescomfPacket = protocolSI.Make(ProtocolSICmdType.DATA, "true");
networkStream.Write(bytescomfPacket, 0, bytescomfPacket.Length);//mandar resposta ao cliente
signaturereceived = true;
}
if (protocolSI.GetCmdType() == ProtocolSICmdType.ASSYM_CIPHER_DATA)
{
datahash = bytedecrypter(protocolSI.GetData());
byte[] bytescomfPacket = protocolSI.Make(ProtocolSICmdType.DATA, "true");
networkStream.Write(bytescomfPacket, 0, bytescomfPacket.Length);//mandar resposta ao cliente
hashreceived = true;
}
}
//receber pacotes com o ficheiro segmentado
while (protocolSI.GetCmdType() != ProtocolSICmdType.EOF)
{
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
if (protocolSI.GetCmdType() == ProtocolSICmdType.PADDING)
{
bytesread = Int32.Parse(stringdecrypter(protocolSI.GetStringFromData()));
byte[] bytescomfPacket = protocolSI.Make(ProtocolSICmdType.DATA, "true");
networkStream.Write(bytescomfPacket, 0, bytescomfPacket.Length);//mandar resposta ao cliente
}
if (protocolSI.GetCmdType() == ProtocolSICmdType.DATA)
{
segment = bytedecrypter(protocolSI.GetData());
copyFileStream.Write(segment, 0, bytesread); // receber ficheiro
byte[] bytescomfPacket = protocolSI.Make(ProtocolSICmdType.DATA, "true");
networkStream.Write(bytescomfPacket, 0, bytescomfPacket.Length);//mandar resposta ao cliente
Console.WriteLine("A receber Dados: " + segment.Length + "b");
}
}
networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length);
string ext = stringdecrypter(protocolSI.GetStringFromData());
byte[] segcomfPacket = protocolSI.Make(ProtocolSICmdType.DATA, "true");
networkStream.Write(segcomfPacket, 0, segcomfPacket.Length);//mandar resposta ao cliente
Console.WriteLine("Transferencia de ficheiro terminada");
copyFileStream.Close();
bool integritystatus = verifyintegrity(datahash, File.ReadAllBytes(copyFilePath), signature);
string integritycheck = string.Empty;
if (integritystatus)
{
integritycheck = "Ficheiro dentro dos parametros de integridade";
}
else
{
integritycheck = "Ficheiro com risco de ter sido modificado";
}
Console.WriteLine("Integrity Check: " + integritycheck);
Random rnd = new Random(DateTime.Now.Millisecond);
int newfilename = rnd.Next(0, 3000); // gere um novo nome para o ficheiro
File.Move(copyFilePath, "C:\\Users\\joaod\\Desktop\\ProjectoTopSeg\\Recursos\\" + newfilename.ToString() + ext); //substitui ficheiros
}
else
{
Console.WriteLine("Pedido de envio de ficheiros negado");
byte[] grantaccess = protocolSI.Make(ProtocolSICmdType.USER_OPTION_9, "false");
networkStream.Write(grantaccess, 0, grantaccess.Length);
}
}
}
Console.WriteLine("Ligaçao terminada");
}
public void threadHandler1()
{
ProtocolSI protocolSI = new ProtocolSI();
NetworkStream networkStream = this.tcpClient.GetStream();
while (protocolSI.GetCmdType() != ProtocolSICmdType.EOT)
{
byte[] ack = protocolSI.Make(ProtocolSICmdType.ACK); // Guarda uma mensagem tipo ACK(Acknowlodge) no array de bytes
try
{
int bytesRead = networkStream.Read(protocolSI.Buffer, 0, protocolSI.Buffer.Length); // Guarda o numero de bytes lidos
switch (protocolSI.GetCmdType())
{
case ProtocolSICmdType.DATA:
byte[] packetData;
string userMsg = protocolSI.GetStringFromData();
string response = "";
Console.WriteLine($"Client {clientID}: " + userMsg);
if (userMsg.StartsWith("!"))
{
userMsg = userMsg.ToLower();
switch (userMsg)
{
case "!horas":
response = DateTime.Now.ToString("HH:mm");
break;
case "!data":
response = DateTime.Now.ToString("dd/MM/yyyy");
break;
case "!piada":
response = "\nComo se chama a neta do Super Mario?\nMarioneta";
break;
default:
response = "Comando Invalido";
break;
}
packetData = protocolSI.Make(ProtocolSICmdType.DATA, response);
networkStream.Write(packetData, 0, packetData.Length);
}
break;
case ProtocolSICmdType.PUBLIC_KEY:
break;
case ProtocolSICmdType.SECRET_KEY:
break;
case ProtocolSICmdType.USER_OPTION_1: // USERNAME
username = protocolSI.GetStringFromData();
break;
case ProtocolSICmdType.USER_OPTION_2: // PASSWORD e Registo
byte[] packetRegister;
try
{
pass = protocolSI.GetData();
salt = GenerateSalt(SALTSIZE);
saltedHash = GenerateSaltedHash(pass, salt);
Console.WriteLine("\nA Fazer Registo ...");
Register(username, saltedHash, salt);
packetRegister = protocolSI.Make(ProtocolSICmdType.DATA, "Sucesso!");
Console.WriteLine("Regiso com Sucesso");
}
catch (Exception)
{
packetRegister = protocolSI.Make(ProtocolSICmdType.DATA, "Erro no Registo!");
Console.WriteLine("Erro no Registo");
}
networkStream.Write(packetRegister, 0, packetRegister.Length);
break;
case ProtocolSICmdType.USER_OPTION_3: // PASSWORD e Login
byte[] packetLogin;
try
{
Console.WriteLine("\nA Fazer Login ...");
if (VerifyLogin(username, protocolSI.GetStringFromData()))
{
packetLogin = protocolSI.Make(ProtocolSICmdType.DATA, "Sucesso!");
Console.WriteLine("Login com Sucesso");
}
else
{
packetLogin = protocolSI.Make(ProtocolSICmdType.DATA, "Login Incorreto!");
Console.WriteLine("Login Incorreto");
}
}
catch (Exception)
{
packetLogin = protocolSI.Make(ProtocolSICmdType.DATA, $"Erro no Login!");
}
networkStream.Write(packetLogin, 0, packetLogin.Length);
break;
case ProtocolSICmdType.EOT:
Console.WriteLine($"Client {clientID} has disconnected");
break;
}
networkStream.Write(ack, 0, ack.Length); // Insere o ack na Stream
}
catch (Exception err)
{
Console.WriteLine($"Cliente {clientID} perdeu a ligação ao servidor!\n*Erro - {err.Message}");
}
}
networkStream.Close(); // Fecha o servico da Stream
tcpClient.Close(); // Encerra o cliente TCP
}