protected override OpResult _Store(PersonalCard _obj)
{
if (_obj == null)
{
return(OpResult.NotifyStoreAction(OpResult.ResultStatus.ObjectIsNull, _obj, "PersonalCard object cannot be created as it is null"));
}
RepositoryMgr.CardMgr.Store(_obj);
_obj.PersonalCardID = _obj.CardRecordID;
if (Exists(_obj))
{
ExecuteNonQuery(GetQuery_UpdateQuery(_obj));
return(OpResult.NotifyStoreAction(OpResult.ResultStatus.Updated, _obj));
}
ExecuteNonQuery(GetQuery_InsertQuery(_obj));
if (_obj.PersonalCardID == null)
{
_obj.PersonalCardID = DbMgr.GetLastInsertID();
}
_obj.FromDb = true;
return(OpResult.NotifyStoreAction(OpResult.ResultStatus.Created, _obj));
}
public DropBoxLinkParams(string accessToken, string localFolderPath, PersonalCard card, string privateKeyPassword)
{
this.AccessToken = accessToken;
this.LocalFolderPath = localFolderPath;
this.Card = card;
this.PrivateKeyPassword = privateKeyPassword;
}
public async Task Confirm(string code)
{
var token = await this.request.Confirm(code);
this.state = States.Confirmed;
try
{
this.privateKeyResponse = await this.DownloadPrivateKey(token);
}
catch (VirgilPrivateServicesException e) when(e.ErrorCode == 40020)
{
throw new PrivateKeyNotFoundException();
}
this.state = States.PrivateKeyDownloaded;
if (VirgilKeyPair.IsPrivateKeyEncrypted(this.privateKeyResponse.PrivateKey) &&
!VirgilKeyPair.CheckPrivateKeyPassword(
this.privateKeyResponse.PrivateKey,
Encoding.UTF8.GetBytes(this.password))
)
{
throw new WrongPrivateKeyPasswordException("Wrong password");
}
var card = new PersonalCard(this.recipientCard, new PrivateKey(this.privateKeyResponse.PrivateKey));
this.aggregator.Publish(new CardLoaded(card, this.password));
this.state = States.Finished;
}
private static Try<PersonalCard> BuildPersonalCard(ConfigureOptions options)
{
var result = new Try<PersonalCard>();
string cardJson = null;
CardModel cardModel = null;
byte[] privateKeyBytes = null;
PrivateKey privateKey = null;
try
{
cardJson = File.ReadAllText(options.VirgilCardPath);
}
catch (Exception)
{
result.AddError("Can't read virgil card file");
}
try
{
if (cardJson != null)
{
cardModel = JsonConvert.DeserializeObject<CardModel>(cardJson);
}
}
catch (Exception)
{
result.AddError("Can't deserialize virgil card from file");
}
try
{
privateKeyBytes = File.ReadAllBytes(options.PrivateKeyPath);
}
catch (Exception)
{
result.AddError("Can't read virgil private card file");
}
try
{
if (privateKeyBytes != null)
{
privateKey = new PrivateKey(privateKeyBytes);
}
}
catch (Exception)
{
result.AddError("Private key file could not be parsed");
}
if (result.IsValid())
{
var pc = new PersonalCard(new RecipientCard(cardModel), privateKey);
result.SetResult(pc);
}
return result;
}
public async Task Setup()
{
this.personalCard = PersonalCard.Import(Settings.Default.PersonalCard);
this.personalCardPassword = "******";
var dropboxClient = new DropboxClientFactory("14c-HsvO9WUAAAAAAAABfMqXv6__GhRIZMYzFK1Dvd3zsTPD-oCbzYWzthLI8DAC").GetInstance();
this.dropBoxCloudStorage = new DropBoxCloudStorage(dropboxClient, this.personalCard, this.personalCardPassword);
}
private DbDeleteStatement GetQuery_DeleteQuery(PersonalCard _obj)
{
DbDeleteStatement clause = DbMgr.CreateDeleteClause();
clause.DeleteFrom("PersonalCards").Criteria.IsEqual("PersonalCards", "PersonalCardID", _obj.PersonalCardID);
return(clause);
}
public DecryptFileOperation(LocalPath source, LocalPath target, PersonalCard personalCard, string password)
{
this.Title = "Decrypt " + source.AsRelativeToRoot();
this.source = source;
this.target = target;
this.personalCard = personalCard;
this.password = password;
}
public StartSyncParams(
PersonalCard personalCard,
string password,
DropboxCredentials dropboxCredentials,
string sourceDir)
{
this.PersonalCard = personalCard;
this.Password = password;
this.DropboxCredentials = dropboxCredentials;
this.SourceDir = sourceDir;
}
public void StoreAccessData(PersonalCard card, string privateKeyPassword)
{
this.CurrentCard = card;
this.PrivateKeyPassword = privateKeyPassword;
this.HasAccount = true;
var data = new StorageDto {
PrivateKeyPassword = this.PrivateKeyPassword, PersonalCard = this.CurrentCard.Export()
};
var json = JsonConvert.SerializeObject(data);
this.storageProvider.Save(json);
}
private async void SelectKey(object arg)
{
try
{
this.ClearErrors();
this.IsBusy = true;
var fileDto = this.SelectedCard;
if (this.SelectedCard == null)
{
this.RaiseErrorMessage("Please select card");
return;
}
var cardDto = await SDK.Domain.ServiceLocator.Services.Cards.Get(fileDto.card.id);
var recipientCard = new RecipientCard(cardDto);
var personalCard = new PersonalCard(recipientCard, new PrivateKey(fileDto.private_key));
if (personalCard.IsPrivateKeyEncrypted && !personalCard.CheckPrivateKeyPassword(this.Password))
{
throw new WrongPrivateKeyPasswordException("Wrong password");
}
try
{
var encrypt = personalCard.Encrypt("test");
personalCard.Decrypt(encrypt, this.Password);
}
catch
{
throw new Exception("Virgil card is malformed");
}
this.aggregator.Publish(new CardLoaded(personalCard, this.Password));
this.aggregator.Publish(new ConfirmationSuccessfull());
}
catch (WrongPrivateKeyPasswordException e)
{
this.AddErrorFor(nameof(this.Password), e.Message);
}
catch (Exception e)
{
this.RaiseErrorMessage(e.Message);
}
finally
{
this.IsBusy = false;
}
}
public LocalFolderLink(string encryptedFolder, string decryptedFolder, PersonalCard personalCard, string privateKeyPassword)
{
this.personalCard = personalCard;
this.privateKeyPassword = privateKeyPassword;
this.encryptedFolder = new LocalFolder(new LocalFolderRoot(encryptedFolder), "Encrypted");
this.decryptedFolder = new LocalFolder(new LocalFolderRoot(decryptedFolder), "Decrypted");
this.encryptedFolder.Subscribe(this);
this.decryptedFolder.Subscribe(this);
this.encryptedFolderWatcher = new LocalFolderWatcher(this.encryptedFolder);
this.decryptedFolderWatcher = new LocalFolderWatcher(this.decryptedFolder);
this.cancellationTokenSource = new CancellationTokenSource();
}
public async Task Confirm(string code)
{
var token = await this.request.Confirm(code);
var card = await PersonalCard.Create(token, this.usePassword?this.password : null, new Dictionary <string, string>
{
["CreatedWith"] = "Virgil.Disk"
});
if (this.uploadPrivateKey)
{
await card.UploadPrivateKey(this.password);
}
this.eventAggregator.Publish(new CardLoaded(card, this.password));
}
public void DecryptWithAnotherPassword(string anotherPassword)
{
if (VirgilKeyPair.IsPrivateKeyEncrypted(this.privateKeyResponse.PrivateKey) &&
!VirgilKeyPair.CheckPrivateKeyPassword(
this.privateKeyResponse.PrivateKey,
Encoding.UTF8.GetBytes(anotherPassword))
)
{
throw new WrongPrivateKeyPasswordException("Wrong password");
}
var card = new PersonalCard(this.recipientCard, new PrivateKey(this.privateKeyResponse.PrivateKey));
this.aggregator.Publish(new CardLoaded(card, anotherPassword));
}
protected override OpResult _Delete(PersonalCard _obj)
{
if (_obj == null)
{
return(OpResult.NotifyDeleteAction(OpResult.ResultStatus.ObjectIsNull, _obj, "PersonalCard object cannot be deleted as it is null"));
}
if (Exists(_obj))
{
ExecuteNonQuery(GetQuery_DeleteQuery(_obj));
RepositoryMgr.CardMgr.Delete(_obj);
return(OpResult.NotifyDeleteAction(OpResult.ResultStatus.ExistsAndDeleted, _obj));
}
return(OpResult.NotifyDeleteAction(OpResult.ResultStatus.NotExists, _obj, "PersonalCard object cannot be deleted as it does not exist"));
}
public void Restore()
{
try
{
var json = this.storageProvider.Load();
var data = JsonConvert.DeserializeObject <StorageDto>(json);
this.PrivateKeyPassword = data.PrivateKeyPassword;
this.CurrentCard = PersonalCard.Import(data.PersonalCard);
this.HasAccount = true;
}
catch (Exception exception)
{
this.PrivateKeyPassword = null;
this.CurrentCard = null;
this.HasAccount = false;
this.Exception = exception;
}
}
public CardLoaded(PersonalCard card, string password)
{
this.Card = card;
this.PrivateKeyPassword = password;
}
public DropBoxCloudStorage(DropboxClient client, PersonalCard personalCard, string privateKeyPassword)
{
this.client = client;
this.credentials = personalCard;
this.privateKeyPassword = privateKeyPassword;
}
private DbInsertStatement GetQuery_InsertQuery(PersonalCard _obj)
{
Dictionary <string, DbFieldEntry> fields = GetFields(_obj);
return(DbMgr.CreateInsertClause("PersonalCards", fields));
}
private DbUpdateStatement GetQuery_UpdateQuery(PersonalCard _obj)
{
return(DbMgr.CreateUpdateClause("PersonalCards", GetFields(_obj), "PersonalCardID", _obj.PersonalCardID));
}