public static void Start()
{
string xmlFile = "Baza.xml"; //source bitmap file
string cipherFile = "Ciphered_EBC.xml"; //result of encryption
string plaintextFile = "Plainxml_EBC.xml"; //result of decryption
string keyFile = "SecretKey_EBC.txt"; //secret key storage
Console.WriteLine("Symmetric Encryption Example - ECB mode");
///Generate secret key for appropriate symmetric algorithm and store it to 'keyFile' for further usage
string secretKey = SecretKey.GenerateKey(AlgorithmType.DES);
SecretKey.StoreKey(secretKey, keyFile);
string eSecretKey = SecretKey.LoadKey(keyFile);
Test_DES_Encrypt(xmlFile, cipherFile, eSecretKey);
///Test_AES_Encrypt(imgFile, cipherFile, eSecretKey);
///Test_3DES_Encrypt(imgFile, cipherFile, eSecretKey);
Console.WriteLine("Encryption is done.");
Console.ReadLine();
Test_DES_Decrypt(cipherFile, plaintextFile, eSecretKey);
///Test_AES_Decrypt(cipherFile, plaintextFile, SecretKey.LoadKey(keyFile));
///Test_3DES_Decrypt(cipherFile, plaintextFile, SecretKey.LoadKey(keyFile));
Console.WriteLine("Decryption is done.");
}
public void PushTopic(Dictionary <byte[], byte[]> signedEncryptedAlarms)
{
/*
* Dictionary<byte[], Alarm> alarms = new Dictionary<byte[], Alarm>();
*
*
* foreach (byte[] sign in signedEncryptedAlarms.Keys)
* {
* alarms.Add(AESInECB.DecryptAlarm(signedEncryptedAlarms[sign], SecretKey.LoadKey(secretKeyPath)));
* }
*/
foreach (var signedAlarmPair in signedEncryptedAlarms)
{
byte[] encryptedAlarm = signedAlarmPair.Value;
byte[] signature = signedAlarmPair.Key;
Alarm alarm = AESInECB.DecryptAlarm(encryptedAlarm, SecretKey.LoadKey(secretKeyPath));
if (AlarmValidator.Validate(alarm, encryptedAlarm, signature))
{
_alarms.Add(alarm);
Console.WriteLine($"Subscriber received {alarm.ToString()}");
//string sign = Encoding.Unicode.GetString(signature);
string sign = Convert.ToBase64String(signature);
string id = Guid.NewGuid().ToString();
writer.Write(alarm.ToString(), id, sign, AlarmValidator.GetSignatureCertificate().GetPublicKeyString());
}
else
{
Console.WriteLine($"Alarm: {alarm} ; rejected.");
}
}
}
public HttpResponseMessage GetDocumentPicture(string path)
{
if (path == null)
{
path = "default-placeholderCrypt.png";
}
var filePath = HttpContext.Current.Server.MapPath("~/Images/" + path);
if (!File.Exists(filePath))
{
path = "default-placeholderCrypt.png";
filePath = HttpContext.Current.Server.MapPath("~/Images/" + path);
}
var ext = Path.GetExtension(filePath);
byte[] contents = null;
string eSecretKey = SecretKey.LoadKey(HttpRuntime.AppDomainAppPath + "Images\\SecretKey.txt");
AES_Symm_Algorithm.DecryptFile(filePath, out contents, eSecretKey);
MemoryStream ms = new MemoryStream(contents);
var response = Request.CreateResponse(HttpStatusCode.OK);
response.Content = new StreamContent(ms);
response.Content.Headers.ContentType = new MediaTypeHeaderValue("image/" + ext);
return(response);
}
internal void StartPublishing()
{
Alarm alarm;
while (true)
{
int risk = GenerateRisk();
AlarmMessagesTypes msg = GenerateMessageType(risk);
alarm = new Alarm(DateTime.Now, risk, msg);
//this.Publish(alarm,CreateSignature(alarm.Message,signCertCN));
try
{
byte[] encrytpedAlarm = AESInECB.EncryptAlarm(alarm, SecretKey.LoadKey(secretKeyPath));
byte[] signature = CreateSignature(encrytpedAlarm, signCertCN);
this.Publish(encrytpedAlarm, signature);
Console.WriteLine($"Published: {alarm}");
}
catch (Exception e)
{
throw new Exception(e.Message);
}
Thread.Sleep(PublishingInterval);
}
}
public void Subscribe(byte[] encryptedFrom, byte[] encryptedTo)
{
Timestamp = DateTime.Now;
int from = AESInECB.DecryptInteger(encryptedFrom, SecretKey.LoadKey(secretKeyPath));
int to = AESInECB.DecryptInteger(encryptedTo, SecretKey.LoadKey(secretKeyPath));
From = from; To = to;
//List<Alarm> data = Repository.alarms.FindAll(x => x.Risk > from && x.Risk < to);
Console.WriteLine($"Subccriber XYZ subcribed to [{from}-{to}]");
SendDelta();
}
public void Publish(byte[] encryptedAlarm, byte[] sign)
{
if (DigitalSignature.Verify(encryptedAlarm, HashAlgorithm.SHA1, sign, GetSignatureCertificate()))
{
Alarm alarm = AESInECB.DecryptAlarm(encryptedAlarm, SecretKey.LoadKey(secretKeyPath));
Repository.signedAlarms.Add(sign, alarm);
Console.WriteLine(alarm);
}
else
{
Console.WriteLine("Signature is INVALID for");
}
}
static void Main(string[] args)
{
/// Define the expected service certificate. It is required to establish cmmunication using certificates.
string srvCertCN = "PubSubService";
NetTcpBinding binding = new NetTcpBinding();
binding.Security.Transport.ClientCredentialType = TcpClientCredentialType.Certificate;
/// Use CertManager class to obtain the certificate based on the "srvCertCN" representing the expected service identity.
X509Certificate2 srvCert = CertManager.GetCertificateFromStorage(StoreName.TrustedPeople, StoreLocation.LocalMachine, srvCertCN);
EndpointAddress address = new EndpointAddress(new Uri("net.tcp://localhost:9999/Subscribers"),
new X509CertificateEndpointIdentity(srvCert));
InstanceContext instanceContext = new InstanceContext(new SubscriberCallbackHandler());
using (SubscriberCallbackProxy proxy = new SubscriberCallbackProxy(instanceContext, binding, address))
{
Console.WriteLine("Define minimum and maximum risk of iterest(integer_integer):");
string input = Console.ReadLine();
string[] ints = input.Split(' ');
int minRisk, maxRisk;
while (ints.Length != 2 || !Int32.TryParse(ints[0], out minRisk) || !Int32.TryParse(ints[1], out maxRisk))
{
Console.WriteLine("Enter 2 proper integers separeted by a space: ");
input = Console.ReadLine();
ints = input.Split(' ');
}
proxy.Subscribe(AESInECB.EncriptInteger(minRisk, SecretKey.LoadKey(secretKeyPath)),
AESInECB.EncriptInteger(maxRisk, SecretKey.LoadKey(secretKeyPath)));
Console.WriteLine($"Subscribed to [{minRisk}-{maxRisk}]");
Console.ReadLine();
Console.ReadLine();
}
}
public static void StartCBC()
{
string imgFile = "Baza.xml"; //source bitmap file
string cipherFile = "Ciphered_CBC.xml"; //result of encryption
string plaintextFile = "Plaintext_CBC.xml"; //result of decryption
string keyFile = "SecretKey_CBC.txt"; //secret key storage
Console.WriteLine("Symmetric Encryption Example - CBC mode");
string secretKey = SecretKey.GenerateKey(AlgorithmType.DES);
SecretKey.StoreKey(secretKey, keyFile);
string eSecretKey = SecretKey.LoadKey(keyFile);
Test_DES_Encrypt(imgFile, cipherFile, eSecretKey);
Console.WriteLine(" CBC Encryption is done.");
Console.ReadLine();
Test_DES_Decrypt(cipherFile, plaintextFile, eSecretKey);
Console.WriteLine(" CBC Decryption is done.");
}
public void SendDelta()
{
while (true)
{
//TODO lock
Dictionary <byte[], Alarm> data = Repository.signedAlarms.Where(
x => x.Value.Risk >= From && x.Value.Risk <= To && x.Value.CreationTime > Timestamp).ToDictionary(x => x.Key, x => x.Value);
if (data.Count != 0)
{
Timestamp = DateTime.Now;
// List<byte[]> encryptedAlarms = new List<byte[]>();
Dictionary <byte[], byte[]> signedEncryptedAlarms = new Dictionary <byte[], byte[]>();
foreach (byte[] key in data.Keys)
{
signedEncryptedAlarms.Add(key, AESInECB.EncryptAlarm(data[key], SecretKey.LoadKey(secretKeyPath)));
}
this.Callback.PushTopic(signedEncryptedAlarms);
data.Clear();
}
Thread.Sleep(50);
}
}
public IHttpActionResult EditUser()
{
var httpRequest = HttpContext.Current.Request;
string imageName = null;
AppUser appUser;
try
{
var username = User.Identity.Name;
var user = _unitOfWork.AppUsers.Find(u => u.Email == username).FirstOrDefault();
if (user == null)
{
return(BadRequest("Data could not be retrieved, try to relog."));
}
appUser = user;
}
catch
{
return(BadRequest("Data could not be retrieved, try to relog."));
}
var jsonObj = JsonConvert.SerializeObject(appUser, Formatting.None, setting);
var eTag = ETagHelper.GetETag(Encoding.UTF8.GetBytes(jsonObj));
if (HttpContext.Current.Request.Headers.Get(ETagHelper.MATCH_HEADER) == null || HttpContext.Current.Request.Headers[ETagHelper.MATCH_HEADER].Trim('"') != eTag)
{
HttpContext.Current.Response.Headers.Add("Access-Control-Expose-Headers", ETagHelper.ETAG_HEADER);
HttpContext.Current.Response.Headers.Add(ETagHelper.ETAG_HEADER, JsonConvert.SerializeObject(eTag));
return(new StatusCodeResult(HttpStatusCode.PreconditionFailed, new HttpRequestMessage()));
}
appUser.FullName = httpRequest["FullName"].Trim();
appUser.BirthDate = DateTime.Parse(httpRequest["BirthDate"]);
appUser.Email = httpRequest["Email"].Trim();
appUser.ProfileEdited = true;
if (appUser.DocumentPicture == null || appUser.DocumentPicture == "")
{
var postedFile = httpRequest.Files["Image"];
if (postedFile != null)
{
imageName = new string(Path.GetFileNameWithoutExtension(postedFile.FileName).Take(10).ToArray()).Replace(" ", "-");
imageName = imageName + DateTime.Now.ToString("yymmssfff") + Path.GetExtension(postedFile.FileName);
var filePath = HttpContext.Current.Server.MapPath("~/Images/" + imageName);
appUser.DocumentPicture = imageName;
byte[] fileData = null;
using (var binaryReader = new BinaryReader(postedFile.InputStream))
{
fileData = binaryReader.ReadBytes(postedFile.ContentLength);
}
string eSecretKey = SecretKey.LoadKey(HttpRuntime.AppDomainAppPath + "Images\\SecretKey.txt");
AES_Symm_Algorithm.EncryptFile(fileData, filePath, eSecretKey);
}
}
jsonObj = JsonConvert.SerializeObject(appUser, Formatting.None, setting);
eTag = ETagHelper.GetETag(Encoding.UTF8.GetBytes(jsonObj));
HttpContext.Current.Response.Headers.Add("Access-Control-Expose-Headers", ETagHelper.ETAG_HEADER);
HttpContext.Current.Response.Headers.Add(ETagHelper.ETAG_HEADER, JsonConvert.SerializeObject(eTag));
try
{
_unitOfWork.AppUsers.Update(appUser);
_unitOfWork.Complete();
}
catch
{
return(BadRequest("Profile could not be edited."));
}
return(Ok(appUser));
}
