public ICipher GetCertificate(string certificatePath)
{
var cert = _cache.GetOrAdd(certificatePath, s =>
{
if (global::System.IO.File.Exists(certificatePath) == false)
{
return(null);
}
var privateKeyPath = $"{certificatePath}.key";
if (global::System.IO.File.Exists(privateKeyPath) == false)
{
privateKeyPath = null;
}
return(RsaCipher.LoadFromPEM(certificatePath, privateKeyPath));
});
if (cert == null)
{
throw new FileNotFoundException("Certificate not Found");
}
return(cert);
}
public void ServiceChannel060Test()
{
var location = System.IO.Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
using (var stream1 = new MemoryStream())
using (var stream2 = new MemoryStream())
using (var clientChannel = new ServiceChannel())
using (var serviceChannel = new ServiceChannel())
{
serviceChannel.SetReadStream(stream1, false);
//serviceChannel.CipherLib["rsa-private"] = RsaCipher.LoadFromPEM($"{location}\\data\\server\\server.pem", $"{location}\\data\\server\\server.pem.key");
clientChannel.SetWriteStream(stream2, false);
clientChannel.Encrypt();
clientChannel.WriteObject("HELO");
clientChannel.CipherLib["rsa-public"] = RsaCipher.LoadFromPEM($"{location}\\data\\server\\server.pem");
clientChannel.Encrypt();
clientChannel.WriteObject("HELO2");
clientChannel.Flush();
Console.WriteLine(stream2.Length);
TransferData(stream2, stream1);
var msg = serviceChannel.ReadObject <string>();
Assert.AreEqual("HELO", msg);
Assert.Catch <SecureChannelException>(() =>
{
var msg2 = serviceChannel.ReadObject <string>();
});
}
}
public void ServiceChannel070Test()
{
var location = System.IO.Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
using (var stream1 = new MemoryStream())
using (var stream2 = new MemoryStream())
using (var clientChannel = new ServiceChannel())
using (var serviceChannel = new ServiceChannel())
{
serviceChannel.SetReadStream(stream1, false);
serviceChannel.CipherLib["rsa-private"] = RsaCipher.LoadFromPEM($"{location}\\data\\server\\server.pem", $"{location}\\data\\server\\server.pem.key");
clientChannel.SetWriteStream(stream2, false);
clientChannel.CipherLib["rsa-public"] = RsaCipher.LoadFromPEM($"{location}\\data\\server\\server.pem");
clientChannel.Encrypt();
var data = Security.Random.Get(128 * 1024 + 1);
clientChannel.Encrypt();
clientChannel.Write(data);
clientChannel.Flush();
Console.WriteLine(stream2.Length);
TransferData(stream2, stream1);
var data1 = serviceChannel.Read();
Assert.AreEqual(Hash.MD5(data), Hash.MD5(data1));
}
}
public void DbxGetKeyCommandTest010()
{
using (var stream1 = new MemoryStream())
using (var channel1 = new ServiceChannel())
using (var channel2 = new ServiceChannel())
{
channel1.SetWriteStream(stream1, canDispose: false);
Context ctx = new Context();
ctx.ClientIP = IPAddress.None;
ctx.Channel = channel1;
ctx.Query = new QueryMessage {
Command = "dbx-GetKey"
};
ctx.Query.Params["username"] = "******";
ctx.Query.Params["uuid"] = "safevault";
ctx.Query.Params["password"] = OneTimePassword.Get(Base32.Decode("12345678"), 0);
Command.Process(ctx);
stream1.Position = 0;
channel2.SetReadStream(stream1, canDispose: false);
channel2.CipherLib["rsa-private"] = RsaCipher
.LoadFromPEM($"{_location}/data/client/test-user/cer.pem", $"{_location}/data/client/test-user/cer.pem.key");
var response = channel2.ReadObject <ResponseMessage>();
Assert.AreEqual(200, response.StatusCode);
var data = response.Header["data"];
Assert.AreEqual("1234567801234567890abcdefghiklmnopqvwxyz12345678012345678901234567890=", data);
}
}
public void HttpService050Test()
{
using (var clientChannel = new HttpServiceChannel(new Uri("http://192.168.0.235:5000/api/safevault")))
{
clientChannel.CipherLib["rsa-public"] = RsaCipher.LoadFromPEM($"data\\server\\server.pem");
clientChannel.CipherLib["rsa-private"] = RsaCipher.LoadFromPEM($"data\\client\\test-user\\cer.pem", $"data\\client\\test-user\\cer.pem.key");
var dbxData = Random.Get(3838);
var qm = new QueryMessage {
Command = "dbx-Upload"
};
qm.Params["username"] = "******";
qm.Params["uuid"] = "safevault";
qm.Params["password"] = "******";
qm.Params["md5"] = Security.Hash.MD5(dbxData);
qm.Params["last-modified"] = "2017-01-01 12:00:00Z";
clientChannel.Encrypt();
clientChannel.WriteObject(qm);
clientChannel.Write(dbxData);
clientChannel.Post();
var response = clientChannel.ReadObject <ResponseMessage>();
Console.WriteLine(response.StatusCode + " " + response.StatusText);
Assert.AreEqual(200, response.StatusCode);
Console.WriteLine(response.Header["data"]);
}
}
public void HttpService040Test()
{
using (var clientChannel = new HttpServiceChannel(new Uri("http://192.168.0.235:5000/api/safevault")))
{
clientChannel.CipherLib["rsa-public"] = RsaCipher.LoadFromPEM($"data\\server\\server.pem");
clientChannel.CipherLib["rsa-private"] = RsaCipher.LoadFromX509Store("Evgeny Zyuzin SafeVault Client");
var qm = new QueryMessage {
Command = "dbx-Download"
};
qm.Params["username"] = "******";
qm.Params["uuid"] = "safevault";
qm.Params["password"] = "******";
clientChannel.Encrypt();
clientChannel.WriteObject(qm);
clientChannel.Post();
var response = clientChannel.ReadObject <ResponseMessage>();
Console.WriteLine(response.StatusCode + " " + response.StatusText);
Assert.AreEqual(200, response.StatusCode);
Console.WriteLine(response.Header["data"]);
var data = clientChannel.Read();
Assert.AreEqual(response.Header["md5"], Security.Hash.MD5(data));
Console.WriteLine(data.Length);
}
}
public void RsaCipherConstructorTest()
{
RsaKey key = null; // TODO: Initialize to an appropriate value
RsaCipher target = new RsaCipher(key);
Assert.Inconclusive("TODO: Implement code to verify target");
}
/// <exception cref="ArgumentNullException">any argument is null</exception>
/// <exception cref="ArgumentException">sourceFileName is empty or destinationFileName is empty</exception>
/// <exception cref="SourceFileNotFoundException">Исходный файл не найден.</exception>
/// <exception cref="UnauthorizedAccessSourceFileException">Ошибка при доступе к исходному файлу.</exception>
/// <exception cref="DestinationFileException">Ошибка при сохранении зашифрованного файла.</exception>
public void Cipher(PublicKey key, string sourceFileName, string destinationFileName)
{
Status = ProcessStatus.Processing;
CurrentBlock = 0;
try {
var rsa = new RsaCipher(key);
using (var reader = CreateFileReader(sourceFileName, key)) {
TotalBlocks = Convert.ToInt32(Math.Ceiling((double)reader.Length / (key.N.Digit - 1)));
using (var writter = factory.CreateRsaFileWriter(destinationFileName, (short)key.N.Digit)) {
writter.WriteHeader(reader.Length, reader.HashCode);
while (!reader.IsDone && Status != ProcessStatus.Stopped)
{
var number = reader.ReadNextBlock();
writter.WriteNextBlock(rsa.Cipher(number));
++CurrentBlock;
OnBlockCompleted();
}
}
}
} catch (Exception) {
Status = ProcessStatus.Stopped;
throw;
}
if (Status == ProcessStatus.Processing)
{
Status = ProcessStatus.Complete;
}
}
public void RsaCipherCipher_Encryption_Test()
{
var rsaKey = RsaCipher.GetKey();
var encrypt = RsaCipher.Encrypt("VeyselMUTLU", rsaKey["PublicKey"]);
var decrypt = RsaCipher.Decrypt(encrypt, rsaKey["PrivateKey"]);
Assert.AreEqual("VeyselMUTLU", decrypt);
}
public void EncryptTest()
{
RsaKey key = null; // TODO: Initialize to an appropriate value
RsaCipher target = new RsaCipher(key); // TODO: Initialize to an appropriate value
byte[] data = null; // TODO: Initialize to an appropriate value
byte[] expected = null; // TODO: Initialize to an appropriate value
byte[] actual;
actual = target.Encrypt(data);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Verify the correctness of this test method.");
}
public bool Decrypt(EncryptedMessage encryptedMessage, int senderId, out string messageText)
{
if (encryptedMessage == null)
{
throw new ArgumentException("Encrypted message cannot be null");
}
if (encryptedMessage.Body == null || encryptedMessage.DigitalSignature == null ||
encryptedMessage.SymmetricKey == null || encryptedMessage.Iv == null)
{
throw new ArgumentException("Not all encrypted message fields are initialized");
}
IContactModel senderContact = _storageService.GetContacts().FirstOrDefault(c => c.Id == senderId);
if (senderContact == null)
{
throw new ArgumentException("Contact with id of senderId does not exist");
}
string receiverKeyPair = _storageService.GetUser().KeyPair;
string senderPublicKey = senderContact.PublicKey;
try
{
// decrypt symmetric key with receivers private key
RsaCipher rsa = new RsaCipher(receiverKeyPair);
byte[] encryptedSymmetricKeyBytes = FormatConverter.String64ToBytes(encryptedMessage.SymmetricKey);
byte[] decryptedSymmetricKeyBytes = rsa.Decrypt(encryptedSymmetricKeyBytes);
// decrypt message text with jsut decrypted symmetric key
byte[] ivBytes = FormatConverter.String64ToBytes(encryptedMessage.Iv);
AesCipher aes = new AesCipher(decryptedSymmetricKeyBytes, ivBytes);
byte[] encryptedMessageBytes = FormatConverter.String64ToBytes(encryptedMessage.Body);
byte[] decryptedMessageBytes = aes.Decrypt(encryptedMessageBytes);
// set message text out parameter
messageText = FormatConverter.BytesToString(decryptedMessageBytes);
// verify digital signature
rsa = new RsaCipher(senderPublicKey);
byte[] digitalSignatureBytes = FormatConverter.String64ToBytes(encryptedMessage.DigitalSignature);
bool signatureOk = rsa.VerifyDigitalSignature(decryptedMessageBytes, digitalSignatureBytes);
return(signatureOk);
}
catch (Exception ex)
{
messageText = null;
return(false);
}
}
public void RsaCipher020Test()
{
var location = System.IO.Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
using (var cipher1 = RsaCipher.LoadFromPEM($"{location}\\data\\client\\test-user\\cer.pem"))
using (var cipher2 = RsaCipher.LoadFromPEM($"{location}\\data\\client\\test-user\\cer.pem", $"{location}\\data\\client\\test-user\\cer.pem.key"))
{
var content = Random.Get(32);
var contentEnc = cipher1.Encrypt(content);
var contentDec = cipher2.Decrypt(contentEnc);
Assert.AreEqual(content, contentDec);
}
}
public void RsaCipherTest()
{
var location = System.IO.Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
using (var cipher1 = RsaCipher.LoadFromPEM($"{location}\\data\\client\\test-user\\cer.pem"))
using (var cipher2 = RsaCipher.LoadFromPEM($"{location}\\data\\client\\test-user\\cer.pem", $"{location}\\data\\client\\test-user\\cer.pem.key"))
{
var content = "password";
var passwordEnc = cipher1.Encrypt(Encoding.UTF8.GetBytes(content));
var password = Encoding.UTF8.GetString(cipher2.Decrypt(passwordEnc));
Assert.AreEqual(content, password);
}
}
public void DbxUploadCommandTest010()
{
if (Directory.Exists($"{_location}/data/client/test-user/dbx"))
{
Directory.Delete($"{_location}/data/client/test-user/dbx", true);
}
using (var stream1 = new MemoryStream())
using (var stream2 = new MemoryStream())
using (var channel1 = new ServiceChannel())
using (var channel2 = new ServiceChannel())
{
byte[] dbxData = Random.Get(256);
channel2.SetReadStream(stream1, canDispose: false);
channel2.SetWriteStream(stream2, canDispose: false);
channel2.Write(dbxData);
stream2.Position = 0;
channel1.SetReadStream(stream2, canDispose: false);
channel1.SetWriteStream(stream1, canDispose: false);
Context ctx = new Context();
ctx.ClientIP = IPAddress.None;
ctx.Channel = channel1;
ctx.Query = new QueryMessage {
Command = "dbx-Upload"
};
ctx.Query.Params["username"] = "******";
ctx.Query.Params["uuid"] = "safevault";
ctx.Query.Params["password"] = "******";
ctx.Query.Params["md5"] = Hash.MD5(dbxData);
ctx.Query.Params["last-modified"] = "2017-01-01 12:00:00Z";
Command.Process(ctx);
stream1.Position = 0;
channel2.CipherLib["rsa-private"] = RsaCipher
.LoadFromPEM($"{_location}/data/client/test-user/cer.pem", $"{_location}/data/client/test-user/cer.pem.key");
var response = channel2.ReadObject <ResponseMessage>();
Assert.AreEqual(200, response.StatusCode);
Assert.AreEqual("OK", response.Header["data"]);
var data = File.ReadAllBytes($"{_location}/data/client/test-user/dbx/safevault.dbx");
Assert.AreEqual(dbxData, data);
var fileInfo = new FileInfo($"{_location}/data/client/test-user/dbx/safevault.dbx");
Assert.AreEqual(fileInfo.CreationTime, DateTime.Parse(ctx.Query.Params["last-modified"]));
}
}
public void EncryptAndDecrypt()
{
var pair = new RsaKeyPair();
var str = "Hello";
var encoded = RsaCipher.Encrypt(str, pair.PublicKey);
Assert.NotEqual(str, encoded);
var decoded = RsaCipher.Decrypt(encoded, pair.PrivateKey);
Assert.Equal(str, decoded);
}
public void ServiceChannel010Test()
{
var location = System.IO.Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
using (var stream1 = new MemoryStream())
using (var stream2 = new MemoryStream())
using (var stream11 = new MemoryStream())
using (var stream21 = new MemoryStream())
using (var clientChannel = new ServiceChannel())
using (var serviceChannel = new ServiceChannel())
{
serviceChannel.SetReadStream(stream1, false);
serviceChannel.CipherLib["rsa-private"] = RsaCipher.LoadFromPEM($"{location}\\data\\server\\server.pem", $"{location}\\data\\server\\server.pem.key");
clientChannel.SetWriteStream(stream2, false);
clientChannel.CipherLib["rsa-public"] = RsaCipher.LoadFromPEM($"{location}\\data\\server\\server.pem");
//clientChannel.CipherLib["rsa-private"] = RsaCipher.LoadFromPEM($"{location}\\data\\client\\test-user\\cer.pem", $"{location}\\data\\client\\test-user\\cer.pem.key");
clientChannel.Encrypt();
clientChannel.WriteObject("HELO");
clientChannel.Flush();
clientChannel.SetReadStream(stream21, false);
Console.WriteLine(stream2.Length);
TransferData(stream2, stream1);
var value = serviceChannel.ReadObject <string>();
Console.WriteLine(value);
Assert.AreEqual("HELO", value);
//clientChannel.CipherLib["rsa-public"] = RsaCipher.LoadFromPEM($"{location}\\data\\client\\test-user\\cer.pem");
serviceChannel.SetWriteStream(stream11, false);
serviceChannel.Encrypt();
serviceChannel.WriteObject("EHLO");
serviceChannel.Flush();
Console.WriteLine(stream11.Length);
TransferData(stream11, stream21);
Console.WriteLine(string.Join(" ", stream21.ToArray().Select(m => $"{m:X2}").ToArray()));
var value1 = clientChannel.ReadObject <string>();
Console.WriteLine(value1);
Assert.AreEqual("EHLO", value1);
}
}
public void Cipher3()
{
// p = 17
// q = 23
// n = p * q = 391
// e = 3
var data = BigNumber.FromBytes(new[] { 14, 1 });
var n = BigNumber.FromBytes(new[] { 135, 1 });
var e = BigNumber.FromBytes(new[] { 3 });
var key = new PublicKey(e, n);
var rsa = new RsaCipher(key);
var result = rsa.Cipher(data);
CheckNumber(result, 60);
}
private HttpServiceChannel CreateHttpServiceChannel()
{
HttpServiceChannel channel = null;
try
{
channel = new HttpServiceChannel(new Uri(_conf.ServerUrl));
channel.CipherLib["rsa-private"] = RsaCipher.LoadFromX509Store(_conf.ClientCertificateName);
channel.CipherLib["rsa-public"] = RsaCipher.LoadFromX509Store(_conf.ServerCertificateName);
}
catch (Exception)
{
channel?.Dispose();
throw;
}
return(channel);
}
public byte[] DecryptSsh1(BigInteger e, BigInteger n, BigInteger encryptedChallenge, byte[] sessionId)
{
var decryptKey = GetKey(e, n);
if (decryptKey == null)
{
return(null);
}
RsaCipher cipher = new RsaCipher((RsaKey)decryptKey.Key.Key);
byte[] decryptedChallenge = cipher.Decrypt(encryptedChallenge.ToByteArray().Reverse().ToArray());
var md5 = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Md5);
byte[] response;
CryptographicBuffer.CopyToByteArray(md5.HashData(CryptographicBuffer.CreateFromByteArray(decryptedChallenge.Concat(sessionId).ToArray())), out response);
return(response);
}
public EncryptedMessage Encrypt(string messageText, int recieverId)
{
if (messageText == null)
{
throw new ArgumentException("Message text cannot be null");
}
IContactModel receiverContact = _storageService.GetContacts().FirstOrDefault(c => c.Id == recieverId);
if (receiverContact == null)
{
throw new ArgumentException("Contact with id of receiverId does not exist");
}
EncryptedMessage encMsg = new EncryptedMessage();
AesCipher aes = new AesCipher();
// set initiazlization vector
encMsg.Iv = FormatConverter.BytesToString64(aes.IV);
// enccrypt message text symmetrically
byte[] messageBytes = FormatConverter.StringToBytes(messageText);
byte[] encryptedMessageBytes = aes.Encrypt(messageBytes);
encMsg.Body = FormatConverter.BytesToString64(encryptedMessageBytes);
// encrypt symmetric key with receivers public key
string receiverPublicKey = receiverContact.PublicKey;
RsaCipher rsa = new RsaCipher(receiverPublicKey);
byte[] encryptedSymmetricKeyBytes = rsa.Encrypt(aes.Key);
encMsg.SymmetricKey = FormatConverter.BytesToString64(encryptedSymmetricKeyBytes);
// create digital signature of message text (using senders private key)
string senderKeyPair = _storageService.GetUser().KeyPair;
rsa = new RsaCipher(senderKeyPair);
byte[] digitalSignatureBytes = rsa.CreateDigitalSignature(messageBytes);
encMsg.DigitalSignature = FormatConverter.BytesToString64(digitalSignatureBytes);
return(encMsg);
}
public void HttpService020Test()
{
using (var clientChannel = new HttpServiceChannel(new Uri("http://192.168.0.235:5000/api/safevault")))
{
clientChannel.CipherLib["rsa-public"] = RsaCipher.LoadFromPEM("data\\server\\server.pem");
clientChannel.CipherLib["rsa-private"] = RsaCipher.LoadFromPEM("data\\client\\test-user\\cer.pem", "data\\client\\test-user\\cer.pem.key");
var queryMessage = new QueryMessage();
queryMessage.Command = "ping";
clientChannel.Encrypt();
clientChannel.WriteObject(queryMessage);
clientChannel.Post();
var response = clientChannel.ReadObject <ResponseMessage>();
Console.WriteLine(response.StatusCode);
Console.WriteLine(response.StatusText);
Console.WriteLine(response.Header["data"]);
Assert.AreEqual(200, response.StatusCode);
//Console.WriteLine(response.Header["data"]);
}
}
private byte[] OpenInternal(KeyProviderQueryContext ctx)
{
SafeVaultConf conf = new SafeVaultConf(ctx.DatabaseIOInfo);
var required = new[] {
conf.ClientCertificateName,
conf.ServerUrl,
conf.ServerCertificateName,
conf.Salt,
conf.Username,
conf.VaultKeyname,
conf.DatabaseKeyA
};
if (required.Any(string.IsNullOrEmpty))
{
throw new ConfigurationException("SafeVault not configured.");
}
byte[] salt = Convert.FromBase64String(conf.Salt);
using (var rsa = RsaCipher.LoadFromX509Store(conf.ClientCertificateName))
{
salt = rsa.Decrypt(salt);
}
string sKeyB = string.Empty;
VaultKeyPromptForm promptForm = new VaultKeyPromptForm();
promptForm.InitEx("Enter SafeVault Password", "Open Database", (oneTimePassword) => {
var query = new SafeVaultWebClient(conf);
try
{
sKeyB = query.GetDbxKey(conf.VaultKeyname, oneTimePassword);
return(true);
}
catch (SafeVaultException ex)
{
MessageService.ShowWarning(
query.Utc != null ? "DateTime: " + DateTime.Parse(query.Utc).ToLocalTime() : "",
ex.Message
);
}
return(false);
});
if (UIUtil.ShowDialogAndDestroy(promptForm) != DialogResult.OK)
{
return(null);
}
byte[] keyA = Convert.FromBase64String(conf.DatabaseKeyA);
byte[] keyB = Convert.FromBase64String(sKeyB);
using (var aes = new Aes256Cipher())
{
aes.SetPassPhrase(salt);
keyA = aes.Decrypt(keyA);
keyB = aes.Decrypt(keyB);
}
if (keyA.Length != keyB.Length)
{
throw new SafevaultKeyProviderException("Incompatible KEYA and KEYB");
}
for (int i = 0; i < keyB.Length; i++)
{
keyA[i] ^= keyB[i];
}
int keyL = BitConverter.ToUInt16(keyA, 0);
if (keyL > keyA.Length)
{
throw new SafevaultKeyProviderException("Invalid KEYB");
}
byte[] masterKey = new byte[keyL];
Array.Copy(keyA, 2, masterKey, 0, masterKey.Length);
return(masterKey);
}
private byte[] Create(KeyProviderQueryContext ctx)
{
var vaultConf = new SafeVaultConf(ctx.DatabaseIOInfo);
var vaultConnectionForm = new VaultConnectionConfigForm();
vaultConnectionForm.InitEx(vaultConf);
if (UIUtil.ShowDialogAndDestroy(vaultConnectionForm) != DialogResult.OK)
{
return(null);
}
VaultKeyCreateForm createForm = new VaultKeyCreateForm();
createForm.InitEx(vaultConf, ctx);
if (UIUtil.ShowDialogAndDestroy(createForm) != DialogResult.OK)
{
return(null);
}
vaultConf.Type = PROVIDER_TYPE;
vaultConf.Version = PROVIDER_VERSION;
var masterKey = Encoding.UTF8.GetBytes(vaultConf.DatabaseKeyA);
var keyLen = (masterKey.Length > 254) ? masterKey.Length : 254;
var keyA = new byte[keyLen + 2];
Array.Copy(BitConverter.GetBytes((ushort)masterKey.Length), keyA, 2);
Array.Copy(masterKey, 0, keyA, 2, masterKey.Length);
var keyB = Random.Get(keyA.Length);
for (int i = 0; i < keyB.Length; i++)
{
keyA[i] ^= keyB[i];
}
var salt = Random.Get(64);
using (var aes = new Aes256Cipher())
{
aes.SetPassPhrase(salt);
keyA = aes.Encrypt(keyA);
keyB = aes.Encrypt(keyB);
}
using (var rsa = RsaCipher.LoadFromX509Store(vaultConf.ClientCertificateName))
{
salt = rsa.Encrypt(salt);
}
vaultConf.Salt = Convert.ToBase64String(salt);
vaultConf.DatabaseKeyA = Convert.ToBase64String(keyA);
vaultConf.VaultKeyname = Guid.NewGuid().ToString();
var databaseKeyB = Convert.ToBase64String(keyB);
VaultKeyPromptForm promptForm = new VaultKeyPromptForm();
promptForm.InitEx("Enter SafeVault Password", "Save KeyB to SafeVault", (oneTimePassword) => {
string status = "";
var query = new SafeVaultWebClient(vaultConf);
try
{
status = Async.Invoke(() => query.SetDbxKey(vaultConf.VaultKeyname, databaseKeyB, oneTimePassword));
if (status == "OK")
{
return(true);
}
MessageService.ShowWarning(
query.Utc != null ? "DateTime: " + DateTime.Parse(query.Utc).ToLocalTime() : "",
status);
}
catch (CryptographicException ex)
{
MessageService.ShowWarning(
query.Utc != null ? "DateTime: " + DateTime.Parse(query.Utc).ToLocalTime() : "",
ex.Message);
}
return(false);
});
if (UIUtil.ShowDialogAndDestroy(promptForm) != DialogResult.OK)
{
return(null);
}
try
{
vaultConf.Save();
}
catch (Exception e)
{
MessageService.ShowWarning(e.Message);
return(null);
}
return(masterKey);
}
public void DbxSetKeyCommandTest010()
{
string newValue = Guid.NewGuid().ToString();
if (File.Exists($"{_location}/data/client/test-user/vault.conf.bak"))
{
File.Delete($"{_location}/data/client/test-user/vault.conf.bak");
}
File.Copy($"{_location}/data/client/test-user/vault.conf", $"{_location}/data/client/test-user/vault.conf.bak");
try
{
using (var stream1 = new MemoryStream())
using (var channel1 = new ServiceChannel())
using (var channel2 = new ServiceChannel())
{
channel1.SetWriteStream(stream1, canDispose: false);
Context ctx = new Context();
ctx.ClientIP = IPAddress.None;
ctx.Channel = channel1;
ctx.Query = new QueryMessage {
Command = "dbx-SetKey"
};
ctx.Query.Params["username"] = "******";
ctx.Query.Params["uuid"] = "safevault";
ctx.Query.Params["password"] = OneTimePassword.Get(Base32.Decode("12345678"), 0);
ctx.Query.Params["value"] = newValue;
Command.Process(ctx);
stream1.Position = 0;
channel2.SetReadStream(stream1, canDispose: false);
channel2.CipherLib["rsa-private"] = RsaCipher
.LoadFromPEM($"{_location}/data/client/test-user/cer.pem",
$"{_location}/data/client/test-user/cer.pem.key");
var response = channel2.ReadObject <ResponseMessage>();
Assert.AreEqual(200, response.StatusCode);
var data = response.Header["data"];
Assert.AreEqual("OK", data);
}
Unity.Resolve <TokenList>().Reset();
using (var stream1 = new MemoryStream())
using (var channel1 = new ServiceChannel())
using (var channel2 = new ServiceChannel())
{
channel1.SetWriteStream(stream1, canDispose: false);
Context ctx = new Context();
ctx.ClientIP = IPAddress.None;
ctx.Channel = channel1;
ctx.Query = new QueryMessage {
Command = "dbx-GetKey"
};
ctx.Query.Params["username"] = "******";
ctx.Query.Params["uuid"] = "safevault";
ctx.Query.Params["password"] = OneTimePassword.Get(Base32.Decode("12345678"), 0);
Command.Process(ctx);
stream1.Position = 0;
channel2.SetReadStream(stream1, canDispose: false);
channel2.CipherLib["rsa-private"] = RsaCipher
.LoadFromPEM($"{_location}/data/client/test-user/cer.pem", $"{_location}/data/client/test-user/cer.pem.key");
var response = channel2.ReadObject <ResponseMessage>();
Assert.AreEqual(200, response.StatusCode);
var data = response.Header["data"];
Assert.AreEqual(newValue, data);
}
}
finally
{
File.Copy($"{_location}/data/client/test-user/vault.conf.bak", $"{_location}/data/client/test-user/vault.conf", true);
File.Delete($"{_location}/data/client/test-user/vault.conf.bak");
}
}
public string GenerateKeyPair()
{
return(RsaCipher.GenerateKeyPair());
}
