public async Task<T> DecryptResponse<T>(Stream responseStream) where T : class
{
EncryptedPayload response = await JsonSerializer.DeserializeAsync<EncryptedPayload>(responseStream, DefaultJsonSettings.Settings);
string decryptedPayload = GetDecryptedPayload(response.EncData);
T responseObj = JsonSerializer.Deserialize<T>(decryptedPayload, DefaultJsonSettings.Settings);
return responseObj;
}
public void EncryptAndDecrypt()
{
String target = " Jack and jill went up the hill to fetch a pale of water";
var payload = EncryptedPayload.Encrypt(new X509Certificate2(_senderPublicPath), target);
string data = EncryptedPayload.Decrypt(new X509Certificate2(_senderPrivatePath), payload);
Assert.AreEqual(target, data, false);
}
internal static void PostSurvey()
{
try
{
_log.Trace("posting survey");
var posturl = Program.Configuration.Survey.PostUrl;
if (!File.Exists(ApplicationDetails.InstanceFiles.SurveyResults))
{
return;
}
var survey = JsonConvert.DeserializeObject <Ghosts.Domain.Messages.MesssagesForServer.Survey>(File.ReadAllText(ApplicationDetails.InstanceFiles.SurveyResults));
var payload = JsonConvert.SerializeObject(survey);
var machine = new ResultMachine();
if (Program.Configuration.Survey.IsSecure)
{
payload = Crypto.EncryptStringAes(payload, machine.Name);
payload = Base64Encoder.Base64Encode(payload);
var p = new EncryptedPayload();
p.Payload = payload;
payload = JsonConvert.SerializeObject(p);
}
using (var client = WebClientBuilder.Build(machine))
{
client.Headers[HttpRequestHeader.ContentType] = "application/json";
client.UploadString(posturl, payload);
}
_log.Trace($"{DateTime.Now} - survey posted to server successfully");
File.Delete(ApplicationDetails.InstanceFiles.SurveyResults);
}
catch (Exception e)
{
_log.Trace("Problem posting logs to server");
_log.Error(e);
}
}
private static void PostResults(string fileName, ResultMachine machine, string postUrl, bool isDeletable = false)
{
var sb = new StringBuilder();
var data = File.ReadLines(fileName);
foreach (var d in data)
{
sb.AppendLine(d);
}
var r = new TransferLogDump();
r.Log = sb.ToString();
var payload = JsonConvert.SerializeObject(r);
if (Program.Configuration.ClientResults.IsSecure)
{
payload = Crypto.EncryptStringAes(payload, machine.Name);
payload = Base64Encoder.Base64Encode(payload);
var p = new EncryptedPayload();
p.Payload = payload;
payload = JsonConvert.SerializeObject(p);
}
using (var client = WebClientBuilder.Build(machine))
{
client.Headers[HttpRequestHeader.ContentType] = "application/json";
client.UploadString(postUrl, payload);
}
if (isDeletable)
{
File.Delete(fileName);
}
else
{
File.WriteAllText(fileName, string.Empty);
}
_log.Trace($"{DateTime.Now} - {fileName} posted to server successfully");
}
public IActionResult Secure([FromBody] EncryptedPayload transmission, CancellationToken ct)
{
string raw;
try
{
var key = Request.Headers["ghosts-name"].ToString();
//decrypt
transmission.Payload = Crypto.Base64Decode(transmission.Payload);
raw = Crypto.DecryptStringAes(transmission.Payload, key);
}
catch (Exception exc)
{
log.Trace(exc);
throw new Exception("Malformed data");
}
//deserialize
var value = JsonConvert.DeserializeObject <TransferLogDump>(raw);
return(Process(HttpContext, Request, value, ct));
}
public static T DecryptWbo <T>(SyncKeys syncKeys, BasicStorageObject wbo)
{
EncryptedPayload payload = JsonConvert.DeserializeObject <EncryptedPayload>(wbo.Payload);
string computedHmac;
HMAC hmac = new HMAC("HMACSHA256", syncKeys.HmacKey);
byte[] ciphertext = Encoding.UTF8.GetBytes(payload.CipherText);
computedHmac = BinaryHelper.ToHexString(hmac.ComputeHash(ciphertext));
if (computedHmac != payload.Hmac)
{
throw new Exception(string.Format("The calculated HMAC is \"{0}\" does not match with the epected one \"{1}\".", computedHmac, payload.Hmac));
}
byte[] iv = Convert.FromBase64String(payload.Iv).Take(16).ToArray();
Aes aes = new Aes(iv, syncKeys.EncKey);
byte[] result = aes.Decrypt(Convert.FromBase64String(payload.CipherText));
string plaintext = Encoding.UTF8.GetString(result, 0, result.Length);
return(JsonConvert.DeserializeObject <T>(plaintext));
}
public async Task <string> DecryptWithKey(byte[] key, EncryptedPayload encryptedData, Encoding encoding = null)
{
if (encoding == null)
{
encoding = Encoding.UTF8;
}
byte[] rawData = encryptedData.data.FromHex();
byte[] iv = encryptedData.iv.FromHex();
byte[] hmacReceived = encryptedData.hmac.FromHex();
using (HMACSHA256 hmac = new HMACSHA256(key))
{
hmac.Initialize();
byte[] toSign = new byte[iv.Length + rawData.Length];
//copy our 2 array into one
Buffer.BlockCopy(rawData, 0, toSign, 0, rawData.Length);
Buffer.BlockCopy(iv, 0, toSign, rawData.Length, iv.Length);
byte[] signature = hmac.ComputeHash(toSign);
if (!signature.SequenceEqual(hmacReceived))
{
throw new InvalidDataException("HMAC Provided does not match expected"); //Ignore
}
}
using (AesManaged cryptor = new AesManaged())
{
cryptor.Mode = CipherMode.CBC;
cryptor.Padding = PaddingMode.PKCS7;
cryptor.KeySize = 256;
cryptor.IV = iv;
cryptor.Key = key;
ICryptoTransform decryptor = cryptor.CreateDecryptor(cryptor.Key, cryptor.IV);
using (MemoryStream ms = new MemoryStream(rawData))
{
using (MemoryStream sink = new MemoryStream())
{
using (CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read))
{
int read = 0;
byte[] buffer = new byte[1024];
do
{
read = await cs.ReadAsync(buffer, 0, buffer.Length);
if (read > 0)
{
await sink.WriteAsync(buffer, 0, read);
}
} while (read > 0);
await cs.FlushAsync();
return(encoding.GetString(sink.ToArray()));
}
}
}
}
}
internal static void PostSurvey()
{
// ignore all certs
ServicePointManager.ServerCertificateValidationCallback += (sender, cert, chain, sslPolicyErrors) => true;
var posturl = string.Empty;
try
{
posturl = Program.Configuration.Survey.PostUrl;
}
catch (Exception exc)
{
_log.Error("Can't get survey posturl!");
return;
}
try
{
_log.Trace("posting survey");
Thread.Sleep(ProcessManager.Jitter(100));
if (!File.Exists(ApplicationDetails.InstanceFiles.SurveyResults))
{
return;
}
var survey = JsonConvert.DeserializeObject <Domain.Messages.MesssagesForServer.Survey>(File.ReadAllText(ApplicationDetails.InstanceFiles.SurveyResults));
var payload = JsonConvert.SerializeObject(survey);
var machine = new ResultMachine();
GuestInfoVars.Load(machine);
if (Program.Configuration.Survey.IsSecure)
{
payload = Crypto.EncryptStringAes(payload, machine.Name);
payload = Base64Encoder.Base64Encode(payload);
var p = new EncryptedPayload();
p.Payload = payload;
payload = JsonConvert.SerializeObject(p);
}
using (var client = WebClientBuilder.Build(machine))
{
client.Headers[HttpRequestHeader.ContentType] = "application/json";
client.UploadString(posturl, payload);
}
_log.Trace($"{DateTime.Now} - survey posted to server successfully");
File.Delete(ApplicationDetails.InstanceFiles.SurveyResults);
}
catch (Exception e)
{
_log.Debug($"Problem posting logs to server from { ApplicationDetails.InstanceFiles.SurveyResults } to { Program.Configuration.Survey.PostUrl }");
_log.Error(e);
}
}
private static void PostClientResults()
{
if (!Program.Configuration.ClientResults.IsEnabled)
{
return;
}
// ignore all certs
ServicePointManager.ServerCertificateValidationCallback += (sender, cert, chain, sslPolicyErrors) => true;
var fileName = ApplicationDetails.LogFiles.ClientUpdates;
var posturl = Program.Configuration.ClientResults.PostUrl;
var machine = new ResultMachine();
GuestInfoVars.Load(machine);
Thread.Sleep(ProcessManager.Jitter(Program.Configuration.ClientResults.CycleSleep));
while (true)
{
try
{
var sb = new StringBuilder();
var data = File.ReadLines(fileName);
foreach (var d in data)
{
sb.AppendLine(d);
}
var r = new TransferLogDump();
r.Log = sb.ToString();
var payload = JsonConvert.SerializeObject(r);
if (Program.Configuration.ClientResults.IsSecure)
{
payload = Crypto.EncryptStringAes(payload, machine.Name);
payload = Crypto.Base64Encode(payload);
var p = new EncryptedPayload();
p.Payload = payload;
payload = JsonConvert.SerializeObject(p);
}
using (var client = WebClientBuilder.Build(machine))
{
client.Headers[HttpRequestHeader.ContentType] = "application/json";
client.UploadString(posturl, payload);
}
File.WriteAllText(fileName, string.Empty);
_log.Trace($"{DateTime.Now} - {fileName} posted to server successfully");
}
catch (Exception e)
{
_log.Debug($"Problem posting logs from { fileName } to server { posturl }");
_log.Error(e);
}
Thread.Sleep(ProcessManager.Jitter(Program.Configuration.ClientResults.CycleSleep));
}
}
