private async Task AuthenticateUserCommandAsync(Stream stream)
{
try
{
var form = SerializerF.Deserialize <IAuthenticationForm>(stream, false);
var result = new ResultOfOperation();
OfflineMessagesConcurent mess;
var formAuthed = await Core.AuthenticateUserAsync(form, CryptoFactoryF, ChoosenCrypto, result).ConfigureAwait(false);
var resultCust = new CurrentResult <OfflineMessagesConcurentSur>(result)
{
Result = (OfflineMessagesConcurentSur)formAuthed.Item2
};
if (result.OperationWasFinishedSuccessful)
{
Form = formAuthed.Item1;
UserIsAuth = true;
}
await ReturnResultToClientAsync(resultCust, true).ConfigureAwait(false);
}
catch (Exception ex)
{
var result = new ResultOfOperation()
{
ErrorMessage = "Во время выполнения команды, по аутентификации," +
" произошла непредвиденная ошибка."
};
await ReturnResultToClientAsync(result, UserIsAuth).ConfigureAwait(false);
}
}
private async Task FinedUserCommandAsync(Stream stream)
{
try
{
if (UserIsAuth)
{
var strName = SerializerF.Deserialize <string>(stream, false);
var forms = await Core.FinedUserAsync(strName, Form.Login).ConfigureAwait(false);
var result = new CurrentResult <ICollection <UserFormSurrogate> >()
{
OperationWasFinishedSuccessful = true,
Result = forms
};
await ReturnResultToClientAsync(result, true).ConfigureAwait(false);
}
else
{
await SendResultWithError(1, 1, false).ConfigureAwait(false);
}
}
catch (Exception ex)
{
var result = new ResultOfOperation()
{
ErrorMessage = "Во время выполнения команды, по нахождению пользователя по логину," +
" произошла непредвиденная ошибка."
};
await ReturnResultToClientAsync(result, UserIsAuth).ConfigureAwait(false);
}
}
private async Task GetPublicKeyCommandAsync()
{
try
{
var encAss = CryptoFactoryF.CreateAsymmetricAlgoritm(ChoosenCrypto.Provider, ChoosenCrypto.Asymmetric);
var keyPublic = encAss.Export(false);
var resultForClient = new CurrentResult <byte[]>()
{
OperationWasFinishedSuccessful = true,
Result = keyPublic
};
await ReturnResultToClientAsync(resultForClient, false).ConfigureAwait(false);
AsymmetricDecrypterF = encAss;
}
catch (Exception ex)
{
var result = new ResultOfOperation()
{
ErrorMessage =
"Во время выполнения операции получения открытого ключа, возникла непредвиденная ошибка."
};
await ReturnResultToClientAsync(result, false).ConfigureAwait(false);
}
}
private async Task GetSessionKey(Stream stream)
{
try
{
Tuple <ICryptoTransform, ICryptoTransform, KeyDataForSymmetricAlgorithm> encSym =
CryptoFactoryF.CreateSymmetricAlgoritm(ChoosenCrypto.Provider, ChoosenCrypto.Symmetric);
var resultForClient = new CurrentResult <KeyDataForSymmetricAlgorithm>()
{
OperationWasFinishedSuccessful = true,
Result = encSym.Item3
};
await ReturnResultToClientAsync(resultForClient, true).ConfigureAwait(false);
EncrypterF = encSym.Item1;
DecryptorF = encSym.Item2;
}
catch (Exception ex)
{
var result = new ResultOfOperation()
{
ErrorMessage =
"Во время выполнения операции получения сессионного ключа, возникла непредвиденная ошибка."
};
await ReturnResultToClientAsync(result, true).ConfigureAwait(false);
}
}
public override Task TextMessageRecieved(string login, string message, ResultOfOperation result,
ContactForm form = null,
bool userIsAuth = true)
{
try
{
if (!userIsAuth)
{
result.OperationWasFinishedSuccessful = false;
result.ErrorMessage = "Аутентификация не была проведена.";
return(Task.CompletedTask);
}
if (form == null)
{
form = ContactsF.First(userForm => userForm.Login.Equals(login));
}
var args = new TextMessageRecievedEventArgs()
{
Message = message, Contact = form
};
result.OperationWasFinishedSuccessful = true;
return(OnTextMessageRecieved(args));
}
catch (InvalidOperationException ex)
{
result.OperationWasFinishedSuccessful = false;
result.ErrorMessage = "Пользователь не зарегистрирован.";
return(Task.CompletedTask);
}
}
public override Tuple <bool, ContactForm> AuthenticateContacnt(ClientToClientAuthForm authForm, CryptoFactoryBase factory, IPEndPoint endPoint,
IEnumerable <ContactForm> publicForms,
ResultOfOperation resultOfOperation)
{
var neededUsers = publicForms.Where(form => form.Login.Equals(authForm.Login)).ToArray();
if (neededUsers.Length != 1)
{
resultOfOperation.ErrorMessage = "Пользователь с таким именем не зарегистрирован.";
resultOfOperation.OperationWasFinishedSuccessful = true;
return(new Tuple <bool, ContactForm>(resultOfOperation.OperationWasFinishedSuccessful, null));
}
var neededUser = neededUsers[0];
if (!endPoint.Address.Equals(neededUser.Ip))
{
resultOfOperation.ErrorMessage = "Аутентификация не удалась.";
resultOfOperation.OperationWasFinishedSuccessful = false;
return(new Tuple <bool, ContactForm>(resultOfOperation.OperationWasFinishedSuccessful, null));
}
if (!authForm.ValidateSign(factory, neededUser.PublicKey))
{
resultOfOperation.ErrorMessage = "Аутентификация не удалась. Не удалось подтвердить подлинность подписи.";
resultOfOperation.OperationWasFinishedSuccessful = false;
return(new Tuple <bool, ContactForm>(resultOfOperation.OperationWasFinishedSuccessful, null));
}
resultOfOperation.OperationWasFinishedSuccessful = true;
return(new Tuple <bool, ContactForm>(resultOfOperation.OperationWasFinishedSuccessful, neededUser));
}
//public override async Task<Tuple<bool, ContactForm>> RegisterNewContactAsync(string login, IPEndPoint endPoint,
// IEnumerable<ContactForm> formsPublic,
// ResultOfOperation resultOfOperation)
//{
// try
// {
// var forms = formsPublic as ContactForm[] ?? formsPublic.ToArray();
// Tuple<bool, ContactForm> authResult = AuthenticateContacnt(login, endPoint, forms, resultOfOperation);
// if (authResult.Item1)
// {
// var form = forms.First(userForm => userForm.Login.Equals(login));
// var args = new RegisterNewContactEventArgs {Ip = endPoint.Address, Login = login};
// await OnRegisterNewContact(args).ConfigureAwait(false);
// if (args.IsAllow)
// ContactsF.Add(form);
// resultOfOperation.OperationWasFinishedSuccessful = true;
// }
// return authResult;
// }
// catch (InvalidOperationException ex)
// {
// resultOfOperation.OperationWasFinishedSuccessful = false;
// resultOfOperation.ErrorMessage = "Пользователь не зарегистрирован на внешнем сервере.";
// return new Tuple<bool, ContactForm>(false, null);
// }
//}
public override async Task <bool> RegisterNewContactAsync(ContactForm form, IPEndPoint endPoint,
ResultOfOperation resultOfOperation)
{
try
{
var args = new RegisterNewContactEventArgs {
Ip = endPoint.Address, Login = form.Login
};
await OnRegisterNewContact(args).ConfigureAwait(false);
if (args.IsAllow)
{
ContactsF.Add(form);
resultOfOperation.OperationWasFinishedSuccessful = true;
}
else
{
resultOfOperation.OperationWasFinishedSuccessful = false;
resultOfOperation.ErrorMessage = "Пользователь отверг запрос на авторизацию.";
}
return(resultOfOperation.OperationWasFinishedSuccessful);
}
catch (Exception ex)
{
throw;
}
}
private Task SendOfflineMessageCommandAsync(Stream stream)
{
try
{
if (UserIsAuth)
{
var offlineMessage = SerializerF.Deserialize <OfflineMessageForm>(stream, false);
var result = new ResultOfOperation();
Core.SendOfflineMessage(offlineMessage, Form, result);
return(ReturnResultToClientAsync(result, true));
}
else
{
return(SendResultWithError(1, 1, false));
}
}
catch (SerializationException ex)
{
return(SendResultWithError(1, 0, true));
}
catch (Exception)
{
return(SendResultWithError(1, 2, true));
}
}
private Task UpdateUserDataCommandAsync(Stream stream)
{
try
{
if (UserIsAuth)
{
var formNew = SerializerF.Deserialize <UserForm>(stream, false);
var result = new ResultOfOperation();
Core.UpdateUserData(ref formNew, result);
Form = formNew;
return(ReturnResultToClientAsync(result, true));
}
else
{
return(SendResultWithError(1, 1, false));
}
}
catch (Exception)
{
var result = new ResultOfOperation()
{
ErrorMessage = "Во время выполнения команды, об отправке offline сообщения," +
" произошла непредвиденная ошибка."
};
return(ReturnResultToClientAsync(result, UserIsAuth));
}
}
public ResultOfOperation UpdateInDataBase(ClassUsers user)
{
var result = new ResultOfOperation(false);
try
{
using (var db = new Entities())
{
var DBRow = db.PaidByUsTransaction.FirstOrDefault(x => x.Id == this.Id);
if (DBRow == null) //create new
{
DBRow = new Entity_Framework.PaidByUsTransaction();
db.PaidByUsTransaction.Add(DBRow);
DBRow.CreatedBy = user.WorkerClockId;
DBRow.CreatedDateTime = DateTime.Now;
var log = PaidByUsCreditCardTransactionLog.First();
db.PaidByUsCreditCardTransactionLog.Add(log);
log.PaidByUsTransaction = DBRow;
DBRow.OriginalAmount = this.OriginalAmount;
DBRow.CustomerName = this.CustomerName;
DBRow.BackOfficeCompany = this.BackOfficeCompany;
DBRow.BillingAmount = this.BillingAmount;
DBRow.BillingCurrencyCode = this.BillingCurrencyCode;
DBRow.Id = this.Id;
DBRow.Item = this.Item;
DBRow.ModifiedBy = this.ModifiedBy;
DBRow.ModifiedDateTime = this.ModifiedDateTime;
DBRow.OriginalCurrencyCode = this.OriginalCurrencyCode;
DBRow.Status = this.Status;
DBRow.SupplierAccountNum = this.SupplierAccountNum;
DBRow.SupplierName = this.SupplierName;
DBRow.TripNumber = this.TripNumber;
}
else //update
{
DBRow.ModifiedBy = user.WorkerClockId;
DBRow.ModifiedDateTime = DateTime.Now;
foreach (var log in PaidByUsCreditCardTransactionLog)
{
var logDBRow = db.PaidByUsCreditCardTransactionLog.FirstOrDefault(x => x.id == log.id);
if (logDBRow != null)
{
logDBRow.Active = log.Active;
}
}
}
DBRow.Status = this.Status;
db.SaveChanges();
this.Id = DBRow.Id;
result.Success = true;
}
}
catch (Exception ex)
{
result.Message = ex.Message;
}
return(result);
}
private ResultOfOperation CreateResultWithError(uint numb, ResultOfOperation result, params object[] objs)
{
result.OperationWasFinishedSuccessful = false;
var strBuilder = new StringBuilder();
var innerNumb = 0;
switch (numb)
{
case 0:
#region RegisterNewUserAsync(UserForm form, string ip, ResultOfOperation resultOfOperation)
innerNumb = (int)objs[0];
switch (innerNumb)
{
case 0:
strBuilder.Append($"Пользователь с именем {objs[1]} уже существует.");
break;
case 1:
strBuilder.Append("Информация для осуществления симметричного шифрования не была задана.");
break;
case 2:
strBuilder.Append(
"Информация для осуществления симметричного шифрования задана не полностью.");
break;
case 3:
strBuilder.Append(
"Не удалось осуществить запись в базу дынных. Возможно стоит повторить запрос.");
break;
case 4:
strBuilder.Append(
"Не удалось осуществить запись в базу дынных. Ошибка ввода/вывода.");
break;
case 5:
strBuilder.Append(
"Не удалось осуществить запись в базу дынных. Ошибка сериализации.");
break;
case 6:
strBuilder.Append(
"Во время регистрации клиента возникла непредвиденная ошибка.");
break;
}
#endregion
break;
}
result.ErrorMessage = strBuilder.ToString();
return(result);
}
public ResultOfOperation ReplaceCard(PaidByUsTransactionDTO transaction, ClassUsers user, int cause)
{
var creditcard = new CreditCard();
var transactionLog = new PaidByUsCreditCardTransactionLog();
var resultOfOperation = new ResultOfOperation();
Entities dblog = new Entities();
var activeLog = dblog.PaidByUsCreditCardTransactionLog.FirstOrDefault(x => x.PaidByUsTransactionId == transaction.Id && x.Active.Value == true);
if (activeLog == null)
{
resultOfOperation.Message = "Active Log Not found";
}
else
{
activeLog.ReplacementCause = cause;
dblog.SaveChanges();
try
{
using (Entities db = new Entities())
{
var lasttransactionLog = db.PaidByUsCreditCardTransactionLog.FirstOrDefault(x => x.id == activeLog.id);
if (lasttransactionLog == null)
{
resultOfOperation.Message = "Active Log Not found in DB: " + activeLog.id;
}
else
{
lasttransactionLog.Active = false;
lasttransactionLog.ReplacementCause = cause;
creditcard = ApllyGetCardAlgorithm(user.WorkerClockId, transaction);
//transactionLog.ImageName = creditcard.ComputeHashForImage();
transactionLog.Active = true;
transactionLog.PaidByUsTransactionId = transaction.Id;
transactionLog.CreditCardRecId = creditcard.RecId;
//DB Operations
db.PaidByUsCreditCardTransactionLog.Add(transactionLog);
db.SaveChanges();
transaction.UpdateInDataBase(user);
resultOfOperation.Additional = transaction.Id.ToString();
resultOfOperation.Success = true;
}
}
}
catch (Exception e)
{
resultOfOperation.Success = false;
resultOfOperation.Message = e.Message;
}
}
return(resultOfOperation);
}
public override async Task <bool> RecieveOfFileTransferRequest(FileRecieveRequest request, IPEndPoint endPoint, ContactForm contact,
ResultOfOperation result)
{
var args = new RecieveOfFileTransferRequestEventArgs()
{
FileName = request.Name,
Login = contact.Login,
Ip = endPoint.Address,
Length = request.Length
};
await OnFileReciveBegining(args).ConfigureAwait(false);
var remoteFile = args.RemoteFileStream;
if (args.IsAllow)
{
if (remoteFile == null)
{
var dirFull = DirForFileSaving + @"\" + request.Name;
var stream = new FileStream(dirFull, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite);
await Task.Run(() => stream.SetLength(request.Length)).ConfigureAwait(false);
MoleClientSender sender;
if (!Senders.TryGetValue(contact.Login, out sender))
{
sender = new MoleClientSender(contact, PossibleAlgs, this, true);
Senders.TryAdd(contact.Login, sender);
}
await sender.Inicialize(endPoint).ConfigureAwait(false);
await sender.GetSessionKey().ConfigureAwait(false);
await sender.AuthenticateAsync().ConfigureAwait(false);
remoteFile = new RemoteFileStreamMole(sender, stream, request.Name);
await remoteFile.InitializeAsync().ConfigureAwait(false);
}
await
OnFileRecievingPrepared(new FileRecievingPreparedEventArgs(request.Name, request.Length, remoteFile))
.ConfigureAwait(false);
result.OperationWasFinishedSuccessful = true;
return(true);
}
result.ErrorMessage = "Пользователь отказался принять файл.";
result.OperationWasFinishedSuccessful = false;
return(false);
}
protected virtual bool ValidateUserFormForRegistration(UserForm form, ResultOfOperation resultOfOperation)
{
if (string.IsNullOrEmpty(form.Login))
{
resultOfOperation.ErrorMessage = "Поле Login является пустой строкой или равно null.";
resultOfOperation.OperationWasFinishedSuccessful = false;
return(false);
}
if (form.KeyParametrsBlob == null || form.KeyParametrsBlob.Key.Length == 0)
{
resultOfOperation.ErrorMessage = "Поле KeyParametrsBlob является пустым массивом байтов или равно null.";
resultOfOperation.OperationWasFinishedSuccessful = false;
return(false);
}
if (string.IsNullOrEmpty(form.Password))
{
resultOfOperation.ErrorMessage = "Поле Password является пустой строкой или равно null.";
resultOfOperation.OperationWasFinishedSuccessful = false;
return(false);
}
if (form.PortClientToClient1 < 50)
{
resultOfOperation.ErrorMessage = "Значение поля PortClientToClient1 является недопустимым.";
resultOfOperation.OperationWasFinishedSuccessful = false;
return(false);
}
if (form.PortClientToClient2 < 50)
{
resultOfOperation.ErrorMessage = "Значение поля PortClientToClient2 является недопустимым.";
resultOfOperation.OperationWasFinishedSuccessful = false;
return(false);
}
if (form.PortClientToClient3 < 50)
{
resultOfOperation.ErrorMessage = "Значение поля PortClientToClient3 является недопустимым.";
resultOfOperation.OperationWasFinishedSuccessful = false;
return(false);
}
if (form.PortServerToClient < 50)
{
resultOfOperation.ErrorMessage = "Значение поля PortServerToClient является недопустимым.";
resultOfOperation.OperationWasFinishedSuccessful = false;
return(false);
}
return(true);
}
/// <exception cref="ArgumentNullException">form == null. -или- resultOfOperation == null.</exception>
public override bool UpdateUserData(ref UserForm form, ResultOfOperation resultOfOperation)
{
if (form == null)
{
throw new ArgumentNullException(nameof(form))
{
Source = GetType().AssemblyQualifiedName
}
}
;
if (resultOfOperation == null)
{
throw new ArgumentNullException(nameof(resultOfOperation))
{
Source = GetType().AssemblyQualifiedName
}
}
;
if (!ValidateUserFormForRegistration(form, resultOfOperation))
{
return(false);
}
try
{
var form1 = form;
var oldForm = UsersF.Users.First(registrationForm => registrationForm.Login.Equals(form1.Login));
oldForm.Update(form1);
UsersF.SaveChanges();
form = form1;
resultOfOperation.OperationWasFinishedSuccessful = true;
return(true);
}
catch (InvalidOperationException)
{
resultOfOperation.ErrorMessage = "Пользователь с таким именем не найден.";
resultOfOperation.OperationWasFinishedSuccessful = false;
return(false);
}
}
private ResultOfOperation CheckCryptoInfo(CryptoInfo cryptoInfo)
{
var CryptoPossible = Core.PossibleCryptoInfo;
var messError = "";
if (!CryptoPossible.Asymmetric.Contains(cryptoInfo.Asymmetric))
{
messError = $"Не был найден ассиметричный алгоритм с таким названием {cryptoInfo.Asymmetric}.";
}
if (!CryptoPossible.Hash.Contains(cryptoInfo.Hash))
{
messError = $"Не был найден алгоритм хеширования с таким названием {cryptoInfo.Hash}.";
}
if (!CryptoPossible.Providers.Contains(cryptoInfo.Provider))
{
messError = $"Не был найден крипто провайдер с таким названием {cryptoInfo.Provider}.";
}
if (!CryptoPossible.Sign.Contains(cryptoInfo.Sign))
{
messError = $"Не был найден алгоритм цифровой подписи с таким названием {cryptoInfo.Sign}.";
}
if (!CryptoPossible.Symmetric.Contains(cryptoInfo.Symmetric))
{
messError = $"Не был найден симметричный алгоритм с таким названием {cryptoInfo.Symmetric}.";
}
var result = new ResultOfOperation();
if (messError != "")
{
result.ErrorMessage = messError;
}
else
{
result.OperationWasFinishedSuccessful = true;
}
return(result);
}
private async Task RegisterNewUserCommandAsync(Stream stream)
{
try
{
var form = SerializerF.Deserialize <UserForm>(stream, false);
form.Ip = ((IPEndPoint)ClientF.Client.RemoteEndPoint).Address;
var result = new ResultOfOperation();
if (await Core.RegisterNewUserAsync(form, RemoteEndPoint.Address, result).ConfigureAwait(false))
{
Form = form;
UserIsAuth = true;
}
await ReturnResultToClientAsync(result, true).ConfigureAwait(false);
}
catch (Exception ex)
{
var result = new ResultOfOperation()
{
ErrorMessage =
"Во время выполнения команды, регистрации нового пользователя, возникла непредвиденная ошибка."
};
await ReturnResultToClientAsync(result, false).ConfigureAwait(false);
}
}
public ResultOfOperation CreateNewTransaction(PaidByUsTransactionDTO transaction, ClassUsers user)
{
var creditcard = new CreditCard();
var resultOfOperation = new ResultOfOperation();
try
{
transaction.Status = (int)Amsalem.Types.Status.Pending;
//Credit Card Operations
creditcard = ApllyGetCardAlgorithm(user.WorkerClockId, transaction);
//TransactionLog Initial
var transactionLog = new PaidByUsCreditCardTransactionLog();
transactionLog.Active = true;
//transactionLog.PaidByUsTransactionId = transaction.Id;
transactionLog.CreditCardRecId = creditcard.RecId;
transaction.PaidByUsCreditCardTransactionLog = new List <PaidByUsCreditCardTransactionLog>();
transaction.PaidByUsCreditCardTransactionLog.Add(transactionLog);
//DB Operations
transaction.UpdateInDataBase(user);
resultOfOperation.Additional = transaction.Id.ToString();
resultOfOperation.Success = true;
}
catch (Exception e)
{
resultOfOperation.Success = false;
resultOfOperation.Additional4 = e.Message;
}
return(resultOfOperation);
}
//public override UserForm GetPublicKey()
//{
// var formNew = new UserForm();
// if (CryptoProvider == CryptoProvider.CngMicrosoft)
// {
// if (AsymmetricAlgorithm is RSACng)
// {
// var rsa = (RSACng) AsymmetricAlgorithm;
// //var cngKeyBlob = rsa.Key.Export(CngKeyBlobFormat.GenericPublicBlob);
// var key = rsa.ExportParameters(false);
// var cngKeyBlob = Serializer.Serialize(key, false);
// formNew = new UserForm()
// {
// CryptoProvider = CryptoProvider.CngMicrosoft,
// PublicKeyParamsBlob = cngKeyBlob
// };
// }
// }
// return formNew;
//}
///// <exception cref="ArgumentNullException">form == null. -или- resultOfOperation == null.</exception>
//public override UserForm AuthenticateUser(UserForm form, out IEnumerable<byte[]> messages,
// ResultOfOperation resultOfOperation)
//{
// if (form == null)
// throw new ArgumentNullException(nameof(form)) { Source = GetType().AssemblyQualifiedName };
// if (resultOfOperation == null)
// throw new ArgumentNullException(nameof(resultOfOperation)) { Source = GetType().AssemblyQualifiedName };
// messages = new byte[0][];
// var formWasFinded = UsersF.FirstOrDefault((registrationForm => registrationForm.Login.Equals(form.Login)));
// var KeyBlob = formWasFinded.SignPublicKeyBlob;
// if (KeyBlob == null)
// {
// resultOfOperation.ErrorMessage = "Пользователь не зарегистрирован.";
// resultOfOperation.OperationWasFinishedSuccessful = false;
// return null;
// }
// form.SignPublicKeyBlob = KeyBlob;
// if (!form.ValidateSign(false, resultOfOperation))
// return null;
// if (OfflineMessagesF.ContainsKey(form.Login))
// messages = OfflineMessagesF[form.Login].MessagesAsBytes.ToArray();
// return form;
//}
/// <exception cref="ArgumentNullException">form == null. -или- resultOfOperation == null.</exception>
public override async Task <Tuple <UserFormSurrogate, OfflineMessagesConcurent> > AuthenticateUserAsync(IAuthenticationForm formAuth,
CryptoFactoryBase cryptoFactory, CryptoInfo choosenCrypto, ResultOfOperation resultOfOperation)
{
if (formAuth == null)
{
throw new ArgumentNullException(nameof(formAuth))
{
Source = GetType().AssemblyQualifiedName
}
}
;
if (resultOfOperation == null)
{
throw new ArgumentNullException(nameof(resultOfOperation))
{
Source = GetType().AssemblyQualifiedName
}
}
;
//messages = null;
try
{
//var formWasFinded = UsersF.First(registrationForm => registrationForm.Login.Equals(formAuth.Login));
var formWasFinded =
await
UsersF.Users.FirstAsync(registrationForm => registrationForm.Login == formAuth.Login)
.ConfigureAwait(false);
switch (formAuth.AuthenticationMethod)
{
case AuthenticationMethod.Classic:
var formClassicAuth = formAuth as IAuthenticationFormClassic;
if (formClassicAuth == null)
{
throw new InvalidCastException("Преобразование из типа IAuthenticationForm в тип " +
"IAuthenticationFormClassic завершилось с ошибкой.")
{
Source = GetType().AssemblyQualifiedName
}
}
;
var hashAlg = cryptoFactory.CreateHashAlgorithm(choosenCrypto.Provider, formClassicAuth.HashAlgotitm);
var hashOfTruePass = hashAlg.ComputeHash(Encoding.UTF8.GetBytes(formWasFinded.Password));
if (hashOfTruePass.SequenceEqual(formClassicAuth.HashOfPassword))
{
resultOfOperation.OperationWasFinishedSuccessful = true;
}
else
{
resultOfOperation.ErrorMessage = "Правильность пароля под сомнением?";
resultOfOperation.OperationWasFinishedSuccessful = false;
}
break;
case AuthenticationMethod.Sign:
var formSignAuth = formAuth as IAuthenticationFormSign;
if (formSignAuth == null)
{
throw new InvalidCastException("Преобразование из типа IAuthenticationForm в тип " +
"IAuthenticationFormSign завершилось с ошибкой.")
{
Source = GetType().AssemblyQualifiedName
}
}
;
var signAlg = cryptoFactory.CreateSignAlgoritm(formSignAuth.CryptoProvider, formSignAuth.SignantureAlgoritmName);
//var signAlg = cryptoFactory.CreateSignAlgoritm(choosenCrypto.Provider, formSignAuth.SignantureAlgoritmName);
signAlg.Import(formWasFinded.KeyParametrsBlob.Key);
if (signAlg.VerifySign(formSignAuth.Hash, formSignAuth.Sign))
{
resultOfOperation.OperationWasFinishedSuccessful = true;
}
else
{
resultOfOperation.ErrorMessage = "Достоверность цифровой подписи под сомнением?";
resultOfOperation.OperationWasFinishedSuccessful = false;
}
break;
}
OfflineMessagesConcurent messages;
OfflineMessagesF.TryRemove(formWasFinded.Login, out messages);
if (messages == null)
{
messages = new OfflineMessagesConcurent(formWasFinded.Login);
}
return(new Tuple <UserFormSurrogate, OfflineMessagesConcurent>(formWasFinded, messages));
}
catch (InvalidOperationException ex)
{
CreateResultWithError(3, resultOfOperation, formAuth.Login);
return(null);
}
}
/// <exception cref="ArgumentNullException">formOfSender == null. -или- OfflineMessageForm == null. -или-
/// resultOfOperation == null.</exception>
public abstract bool SendOfflineMessage(OfflineMessageForm offlineMessage, UserForm formOfSender,
ResultOfOperation resultOfOperation);
/// <exception cref="ArgumentNullException">formOfSender == null. -или- OfflineMessageForm == null. -или-
/// resultOfOperation == null.</exception>
public override bool SendOfflineMessage(OfflineMessageForm offlineMessage, UserForm formOfSender,
ResultOfOperation resultOfOperation)
{
if (formOfSender == null)
{
throw new ArgumentNullException(nameof(formOfSender))
{
Source = GetType().AssemblyQualifiedName
}
}
;
if (offlineMessage == null)
{
throw new ArgumentNullException(nameof(offlineMessage))
{
Source = GetType().AssemblyQualifiedName
}
}
;
if (resultOfOperation == null)
{
throw new ArgumentNullException(nameof(resultOfOperation))
{
Source = GetType().AssemblyQualifiedName
}
}
;
try
{
var receiver = (UserForm)UsersF.Users.First((form => form.Login == offlineMessage.LoginOfReciever));
while (true)
{
OfflineMessagesConcurent messages;
if (!receiver.ValidateIpAdressesAndPorts(1, false, resultOfOperation))
{
//OfflineMessagesConcurent messagesConcurentOffline;
if (OfflineMessagesF.TryGetValue(receiver.Login, out messages))
{
if (messages.Count > 50)
{
resultOfOperation.ErrorMessage = "Кол-во сообщений для офлайн пользователей не может превышать 50.";
resultOfOperation.OperationWasFinishedSuccessful = false;
return(false);
}
//messagesConcurentOffline =
// messages.Where(
// offlineMessages => offlineMessages.FormOfSender.Login.Equals(formOfSender.Login))
// .ToArray()[0];
//if (messagesConcurentOffline == null)
//{
// messagesConcurentOffline = new OfflineMessagesConcurent(formOfSender);
// messages.Add(messagesConcurentOffline);
//}
messages.Add(formOfSender.Login, offlineMessage.Message);
//messagesConcurentOffline.Messages.Add(offlineMessage.Message);
resultOfOperation.OperationWasFinishedSuccessful = true;
return(true);
}
else
{
while (true)
{
messages = new OfflineMessagesConcurent(offlineMessage.LoginOfReciever);
if (OfflineMessagesF.TryAdd(offlineMessage.LoginOfReciever, messages))
{
messages.Add(formOfSender.Login, offlineMessage.Message);
break;
}
else
{
if (OfflineMessagesF.TryGetValue(receiver.Login, out messages))
{
messages.Add(formOfSender.Login, offlineMessage.Message);
break;
}
}
}
}
}
else
{
resultOfOperation.ErrorMessage = "Пользователь находится в сети.";
resultOfOperation.OperationWasFinishedSuccessful = false;
return(false);
}
}
}
catch (InvalidOperationException)
{
resultOfOperation.ErrorMessage = "Пользователь получатель не зарегистрирован.";
resultOfOperation.OperationWasFinishedSuccessful = false;
return(false);
}
}
private Task SendResultWithError(int numb, int innerNumb, bool useEnc, params object[] objs)
{
ResultOfOperation result = null;
var str = new StringBuilder();
switch (numb)
{
case 0:
#region ReadCryptoDataAsync(byte[] bytesEnc, bool useAsymmetricCrypt)
switch (innerNumb)
{
case 0:
result = new ResultOfOperation()
{
ErrorMessage = "Заранее не были определены криптографические алгоритмы."
};
break;
case 1:
//SendResultWithError(0, 1, 0useAsymmetricCrypt)
str.AppendLine("Во время расшифровки сообщения возникла криптографическая ошибка.");
str.Append($"Ассиметричное шифрование включено {objs[0]}.");
result = new ResultOfOperation()
{
ErrorMessage = str.ToString()
};
break;
case 2:
result = new ResultOfOperation()
{
ErrorMessage =
"Были определены криптографические алгоритмы, но не были запрошены ключи."
};
break;
}
#endregion
break;
case 1:
#region SendOfflineMessageCommandAsync(Stream stream)
switch (innerNumb)
{
case 0:
result = new ResultOfOperation()
{
ErrorMessage = "Произошла ошибка во время десеарелизации. Ожидался тип OfflineMessageForm."
};
break;
case 1:
result = new ResultOfOperation()
{
ErrorMessage = "Авторизация не была проведена."
};
break;
case 2:
result = new ResultOfOperation()
{
ErrorMessage =
"При обработке команды на отправку offline сообщения возникла непредвиденная ошибка."
};
break;
}
#endregion
break;
case 2:
#region SetPublicKey(Stream stream)
switch (innerNumb)
{
case 0:
result = new ResultOfOperation()
{
ErrorMessage = "Длина массива байт, представляющая открытый ключ, равна 0."
};
break;
case 1:
result = new ResultOfOperation()
{
ErrorMessage = "Не удалось импортировать открытый ключ."
};
break;
}
#endregion
break;
}
if (result == null)
{
result = new ResultOfOperation()
{
ErrorMessage = "Не нашлось нормального описания ошибки."
}
}
;
return(ReturnResultToClientAsync(result, useEnc));
}
}
/// <exception cref="SerializationException"></exception>
private async Task ReturnResultToClientAsync(ResultOfOperation result, bool useEncryption)
{
try
{
var contentForEnc = SerializerF.Serialize(result, false);
byte[] contentEnc;
var useEnc = false;
if (useEncryption)
{
if (EncrypterF == null)
{
if (AsymmetricEncrypterF == null)
{
contentEnc = contentForEnc;
}
else
{
useEnc = true;
contentEnc = await AsymmetricEncrypterF.EncryptAsync(contentForEnc).ConfigureAwait(false);
}
}
else
{
useEnc = true;
contentEnc = EncrypterF.TransformFinalBlock(contentForEnc, 0, contentForEnc.Length);
}
}
else
{
contentEnc = contentForEnc;
}
var writer = new BinaryWriter(NetStreamF);
writer.Write(useEnc);
writer.Write(contentEnc.Length);
await NetStreamF.WriteAsync(contentEnc, 0, contentEnc.Length).ConfigureAwait(false);
}
catch (SerializationException ex)
{
ex.Source = GetType().AssemblyQualifiedName;
throw;
}
catch (CryptographicException ex)
{
var result2 = new ResultOfOperation()
{
ErrorMessage = "При подготовке к отправке сообщения возникла криптографическая ошибка."
};
await ReturnResultToClientAsync(result2, false).ConfigureAwait(false);
}
catch (SocketException ex)
{
}
catch (Exception ex)
{
var result2 = new ResultOfOperation()
{
ErrorMessage = "При подготовке к отправке сообщения возникла непредвиденная ошибка."
};
await ReturnResultToClientAsync(result2, false).ConfigureAwait(false);
}
}
private Task ReadCommandAndMapAsync(Stream stream)
{
Task resultTask = Task.CompletedTask;
if (stream.Length >= 2) //UInt16 - 2 byte
{
//var stream = new MemoryStream(bytesFromSocket);
using (stream)
{
var readerBin = new BinaryReader(stream);
var command = readerBin.ReadUInt16();
switch (command)
{
case 0:
resultTask = GetPublicKeyCommandAsync();
break;
case 1:
resultTask = RegisterNewUserCommandAsync(stream);
break;
case 2:
resultTask = AuthenticateUserCommandAsync(stream);
break;
case 3:
resultTask = SetCryptoAlgs(stream);
break;
case 4:
resultTask = FinedUserCommandAsync(stream);
break;
case 5:
resultTask = UpdateUserDataCommandAsync(stream);
break;
case 6:
resultTask = SendOfflineMessageCommandAsync(stream);
break;
case 7:
resultTask = GetSessionKey(stream);
break;
case 8:
resultTask = GetPossibleCryptoAlgs();
break;
case 9:
resultTask = SetPublicKey(stream);
break;
default:
var result = new ResultOfOperation()
{
ErrorMessage = "Команды с таким номером не существует."
};
resultTask = ReturnResultToClientAsync(result, false);
//var resultAsBytes = SerializerF.Serialize(result);
//resultTask = NetStreamF.WriteAsync(resultAsBytes, 0, resultAsBytes.Length);
break;
}
}
}
else
{
var result = new ResultOfOperation()
{
ErrorMessage = "Команда для сервера не задана."
};
resultTask = ReturnResultToClientAsync(result, false);
//var resultAsBytes = SerializerF.Serialize(result);
//resultTask = NetStreamF.WriteAsync(resultAsBytes, 0, resultAsBytes.Length);
}
return(resultTask);
}
/// <exception cref="ArgumentNullException">form == null. -или- resultOfOperation == null.</exception> public abstract bool UpdateUserData(ref UserForm form, ResultOfOperation resultOfOperation);
public bool VerifyPassword(string password, ResultOfOperation resultOfOperation)
{
throw new NotImplementedException();
}
///// <exception cref="ArgumentNullException">form == null. -или- ip == null. -или- resultOfOperation == null.</exception>
///// <exception cref="ArgumentOutOfRangeException">Строка не является ip адресом.</exception>
//public abstract bool RegisterNewUser(UserForm form, IPAddress ip, ResultOfOperation resultOfOperation);
/// <exception cref="ArgumentNullException">form == null. -или- ip == null. -или- resultOfOperation == null.</exception>
/// <exception cref="ArgumentOutOfRangeException">Строка не является ip адресом.</exception>
public abstract Task <bool> RegisterNewUserAsync(UserForm form, IPAddress ip,
ResultOfOperation resultOfOperation);
///// <exception cref="ArgumentNullException">form == null. -или- ip == null. -или- resultOfOperation == null.</exception>
///// <exception cref="ArgumentOutOfRangeException">Строка не является ip адресом.</exception>
//public override bool RegisterNewUser(UserForm form, IPAddress ip, ResultOfOperation resultOfOperation)
//{
// if (form == null)
// throw new ArgumentNullException(nameof(form)) {Source = GetType().AssemblyQualifiedName};
// if (form.Login == null)
// throw new ArgumentNullException(nameof(form.Login));
// if (ip == null)
// throw new ArgumentNullException(nameof(ip)) {Source = GetType().AssemblyQualifiedName};
// if (resultOfOperation == null)
// throw new ArgumentNullException(nameof(resultOfOperation)) { Source = GetType().AssemblyQualifiedName };
// //IPAddress address;
// //if (!IPAddress.TryParse(ip, out address))
// // throw new ArgumentOutOfRangeException(nameof(ip), "Строка не является ip адресом.")
// //{
// // Source = GetType().AssemblyQualifiedName
// //};
// if (UsersF.Where((info => info.Login == form.Login)).Any())
// return CreateResultWithError(0, resultOfOperation, form.Login).OperationWasFinishedSuccessful;
// form.Ip = ip;
// //if (!form.ValidateBlobFormat(resultOfOperation, false, false))
// // return false;
// if (! await Task.Run(() => form.ValidateIpAdressesAndPorts(3, false, resultOfOperation)).ConfigureAwait(false))
// return false;
// //if (form.DataForSymmetricAlgorithm == null)
// // return CreateResultWithError(1, resultOfOperation).OperationWasFinishedSuccessful;
// //else
// //{
// // if (form.DataForSymmetricAlgorithm.SymmetricIvBlob == null ||
// // form.DataForSymmetricAlgorithm.SymmetricIvBlob.Length == 0 ||
// // form.DataForSymmetricAlgorithm.SymmetricKeyBlob == null ||
// // form.DataForSymmetricAlgorithm.SymmetricKeyBlob.Length == 0)
// // return CreateResultWithError(2, resultOfOperation).OperationWasFinishedSuccessful;
// //}
// resultOfOperation.OperationWasFinishedSuccessful = true;
// UsersF.TryAdd(form);
// return true;
//}
/// <exception cref="ArgumentNullException">form == null. -или- ip == null. -или- resultOfOperation == null.</exception>
/// <exception cref="ArgumentOutOfRangeException">Строка не является ip адресом.</exception>
public override async Task <bool> RegisterNewUserAsync(UserForm form, IPAddress ip,
ResultOfOperation resultOfOperation)
{
var validateTask = Task.Run(() =>
{
if (form == null)
{
throw new ArgumentNullException(nameof(form))
{
Source = GetType().AssemblyQualifiedName
}
}
;
if (ip == null)
{
throw new ArgumentNullException(nameof(ip))
{
Source = GetType().AssemblyQualifiedName
}
}
;
if (resultOfOperation == null)
{
throw new ArgumentNullException(nameof(resultOfOperation))
{
Source = GetType().AssemblyQualifiedName
}
}
;
var isExist = UsersF.Users.Any(surrogate => surrogate.Login == form.Login);
if (isExist)
{
return(CreateResultWithError(0, resultOfOperation, 0, form.Login).OperationWasFinishedSuccessful);
}
if (!ValidateUserFormForRegistration(form, resultOfOperation))
{
return(false);
}
if (!form.ValidateIpAdressesAndPorts(3, false, resultOfOperation))
{
return(false);
}
return(true);
});
if (!await validateTask.ConfigureAwait(false))
{
return(false);
}
try
{
await UsersF.Users.AddAsync(form).ConfigureAwait(false);
await UsersF.SaveChangesAsync().ConfigureAwait(false);
resultOfOperation.OperationWasFinishedSuccessful = true;
return(resultOfOperation.OperationWasFinishedSuccessful);
//seria
}
//catch (SerializationException ex)
// when (Type.GetType(ex.Source).GetTypeInfo().GetInterface("IFileEngine<UserForm>") != null)
//{
// return CreateResultWithError(0, resultOfOperation, 5).OperationWasFinishedSuccessful;
//}
catch (SerializationException ex)
when(
Type.GetType(ex.Source)
.GetTypeInfo()
.ImplementedInterfaces.FirstOrDefault(type => type.FullName.Contains("IFileEngine<UserForm>")) !=
null)
{
return(CreateResultWithError(0, resultOfOperation, 5).OperationWasFinishedSuccessful);
}
//catch (IOException ex)
// when (Type.GetType(ex.Source).GetTypeInfo().GetInterface("IFileEngine<UserForm>") != null)
//{
// return CreateResultWithError(0, resultOfOperation, 4).OperationWasFinishedSuccessful;
//}
catch (IOException ex)
when(Type.GetType(ex.Source)
.GetTypeInfo()
.ImplementedInterfaces.FirstOrDefault(type => type.FullName.Contains("IFileEngine<UserForm>")) !=
null)
{
return(CreateResultWithError(0, resultOfOperation, 4).OperationWasFinishedSuccessful);
}
catch (Exception ex)
{
return(CreateResultWithError(0, resultOfOperation, 6).OperationWasFinishedSuccessful);
}
}
///// <summary>
///// Возвращает форму с скопированными данными, а именно: Ip, CryptoProvider, SignPublicKeyBlob, PublicKeyParamsBlob,
///// Login, PortClientToClient1, PortClientToClient2, PortClientToClient3, PortServerToClient. Если тип ссылочный,
///// то будет скопирована ссылка.
///// </summary>
//public ContactForm GetUserPublicData()
//{
// var clone = new ContactForm()
// {
// Ip = Ip,
// CryptoProvider = CryptoProvider,
// SignPublicKeyBlob = SignPublicKeyBlob,
// PublicKeyParamsBlob = PublicKeyParamsBlob,
// Login = Login,
// PortClientToClient1 = PortClientToClient1,
// PortClientToClient2 = PortClientToClient2,
// PortClientToClient3 = PortClientToClient3,
// PortServerToClient = PortServerToClient
// };
// return clone;
//}
/// <exception cref="PlatformNotSupportedException">Классы криптографии следующего поколения (CNG) не поддерживаются данной системой.</exception>
/// <exception cref="CryptographicException">Все остальные ошибки.</exception>
/// <exception cref="InvalidOperationException">Свойство <see cref="SignPublicKeyBlob"/> не задано.</exception>
public bool ValidateIpAdressesAndPorts(ushort numbOfPortsForValidation, bool throwExc,
ResultOfOperation resultOfOperation)
{
if (numbOfPortsForValidation > 3)
{
throw new ArgumentOutOfRangeException(nameof(numbOfPortsForValidation),
"Значение не попадает в диапазон от 1 до 3.")
{
Source = GetType().AssemblyQualifiedName
}
}
;
if (resultOfOperation == null)
{
throw new ArgumentNullException(nameof(resultOfOperation))
{
Source = GetType().AssemblyQualifiedName
}
}
;
if (Ip == null)
{
if (throwExc)
{
throw new ArgumentNullException(nameof(Ip))
{
Source = GetType().AssemblyQualifiedName
}
}
;
resultOfOperation.ErrorMessage = "Не задан ip адрес.";
resultOfOperation.OperationWasFinishedSuccessful = false;
return(false);
}
var ports = new int[0];
switch (numbOfPortsForValidation)
{
case 1:
ports = new[] { PortClientToClient1 };
break;
case 2:
ports = new[] { PortClientToClient1, PortClientToClient2 };
break;
case 3:
ports = new[] { PortClientToClient1, PortClientToClient2, PortClientToClient3 };
break;
}
ushort i = 0;
try
{
for (i = 0; i < numbOfPortsForValidation; i++)
{
if (ports[i] == 0)
{
if (throwExc)
{
throw new ArgumentException("Не задан какой-либо из портов.")
{
Source = GetType().AssemblyQualifiedName
}
}
;
resultOfOperation.ErrorMessage = "Не задан какой-либо из портов.";
resultOfOperation.OperationWasFinishedSuccessful = false;
return(false);
}
var endPoint = new IPEndPoint(Ip, ports[i]);
using (var client = new TcpClient())
{
var connectTask = client.ConnectAsync(Ip, ports[i]);
connectTask.Wait();
}
}
return(true);
}
catch (AggregateException ex) when(ex.InnerException is SocketException)
{
if (throwExc)
{
throw CreateException(0, i, ex);
}
resultOfOperation.ErrorMessage = $"Порт {i} не отвечает.";
resultOfOperation.OperationWasFinishedSuccessful = false;
return(false);
}
catch (SocketException ex)
{
if (throwExc)
{
throw CreateException(0, i, ex);
}
resultOfOperation.ErrorMessage = $"Порт {i} не отвечает.";
resultOfOperation.OperationWasFinishedSuccessful = false;
return(false);
}
}
//public abstract UserForm GetPublicKey();
/// <exception cref="ArgumentNullException">form == null. -или- resultOfOperation == null.</exception>
public abstract Task <Tuple <UserFormSurrogate, OfflineMessagesConcurent> > AuthenticateUserAsync(
IAuthenticationForm formAuth,
CryptoFactoryBase cryptoFactory, CryptoInfo choosenCrypto, ResultOfOperation resultOfOperation);
