public T DeserializeAndDencryptMgmtInboundData <T>(string data)
{
KeyPair keyPair = _keyPairService.GetManagementKeyPair();
string unencryptedData = _asymmetricEncryptionProvider.DecryptPublic(data, keyPair);
return(_objectSerializationProvider.Deserialize <T>(unencryptedData));
}
public StatusRequestResult GetServiceStatus(string url, string token, EncryptionInfo encryptionInfo)
{
StatusServiceClient client = StatusServiceClientCreator(url);
string encryptedToken = _symmetricEncryptionProvider.Encrypt(token, encryptionInfo);
string serviceResult = client.GetServiceStatus(encryptedToken);
string result = _symmetricEncryptionProvider.Decrypt(serviceResult, encryptionInfo);
StatusRequestResult statusRequestResult = _objectSerializationProvider.Deserialize <StatusRequestResult>(result);
return(statusRequestResult);
}
public GetAllActivationLogsResult GetAllServiceActivationLogs(string url, string token, EncryptionInfo encryptionInfo, KeyPair serviceKeys)
{
ReportingServiceClient client = ReportingClientCreator(url);
string encryptedToken = _symmetricEncryptionProvider.Encrypt(token, encryptionInfo);
string encryptedResult = client.GetAllActivationLogs(encryptedToken);
string decryptedResult = _asymmetricEncryptionProvider.DecryptPublic(encryptedResult, serviceKeys);
GetAllActivationLogsResult result = _objectSerializationProvider.Deserialize <GetAllActivationLogsResult>(decryptedResult);
return(result);
}
public AddProductResult AddProduct(string url, string token,
EncryptionInfo encryptionInfo, KeyPair serviceKeys, ServiceProduct product)
{
ProductsServiceClient client = ProductClientCreator(url);
string encryptedToken = _symmetricEncryptionProvider.Encrypt(token, encryptionInfo);
string serializedPayload = _objectSerializationProvider.Serialize(product);
string encryptedData = _asymmetricEncryptionProvider.EncryptPrivate(serializedPayload, serviceKeys);
string encryptedResult = client.AddProduct(encryptedToken, encryptedData);
string decryptedResult = _asymmetricEncryptionProvider.DecryptPublic(encryptedResult, serviceKeys);
AddProductResult result = _objectSerializationProvider.Deserialize <AddProductResult>(decryptedResult);
return(result);
}
public string ActivateLicense(string token, string payload)
{
ActivationResult result = new ActivationResult();
KeyPair keyPair = _keyPairService.GetClientKeyPair();
Debug.WriteLine(keyPair.PrivateKey);
Debug.WriteLine(keyPair.PublicKey);
if (!_controlService.ValidateClientToken(token))
{
result.WasOperationSuccessful = false;
result.WasRequestValid = false;
result.ActivationSuccessful = false;
return(SerializeAndEncryptResult(result, keyPair));
}
result.WasRequestValid = true;
result.ServiceId = _masterService.GetMasterServiceData().ServiceId;
string decryptedPayload = _asymmetricEncryptionProvider.DecryptPublic(payload, keyPair);
LicenseActivationPayload activationPayload = _serializationProvider.Deserialize <LicenseActivationPayload>(decryptedPayload);
if (!_keyService.AuthorizeLicenseForActivation(activationPayload.LicenseKey, activationPayload.ServiceLicense, activationPayload.HardwareFingerprint))
{
result.WasOperationSuccessful = false;
result.ActivationSuccessful = false;
}
else
{
Guid?activiationtoken = _keyService.ActivateLicenseKey(activationPayload.LicenseKey, activationPayload.Token,
activationPayload.ServiceLicense, activationPayload.HardwareFingerprint);
if (activiationtoken.HasValue)
{
_activationLogService.LogActiviation(activationPayload.LicenseKey, ActivationResults.Success, GetIpAddress());
result.ActivationToken = activiationtoken;
result.WasOperationSuccessful = true;
result.ActivationSuccessful = true;
}
else
{
_activationLogService.LogActiviation(activationPayload.LicenseKey, ActivationResults.ActivationFailure, GetIpAddress());
result.WasOperationSuccessful = false;
result.ActivationSuccessful = false;
}
}
return(SerializeAndEncryptResult(result, keyPair));
}
public ActivationResult ActivateLicense(string url, string token, EncryptionInfo encryptionInfo,
LicenseActivationPayload payload, ClientLicense clientLicense)
{
ActivationServiceClient client = ActivationServiceClientCreator(url);
string encryptedToken = _symmetricEncryptionProvider.Encrypt(token, encryptionInfo);
string serializedPayload = _objectSerializationProvider.Serialize(payload);
string encryptedData = _asymmetricEncryptionProvider.EncryptPrivate(serializedPayload, clientLicense.ServicesKeys);
string serviceResult = client.ActivateLicense(encryptedToken, encryptedData);
string result = _asymmetricEncryptionProvider.DecryptPublic(serviceResult, clientLicense.ServicesKeys);
ActivationResult activationResult = _objectSerializationProvider.Deserialize <ActivationResult>(result);
return(activationResult);
}
public MasterConfiguration GetMasterConfiguration(EncryptionInfo encryptionInfo)
{
if (File.Exists(Name) == false)
{
return(null);
}
string rawFileData;
using (StreamReader reader = new StreamReader(Name))
{
rawFileData = reader.ReadToEnd();
}
string plainTextObjectData;
plainTextObjectData = _encryptionProvider.Decrypt(rawFileData, encryptionInfo);
MasterConfiguration mc = _objectSerializationProvider.Deserialize <MasterConfiguration>(plainTextObjectData);
return(mc);
}
public Database GetDatabaseProject(string path)
{
if (File.Exists(path) == false)
{
return(null);
}
string rawFileData;
using (StreamReader reader = new StreamReader(path))
{
rawFileData = reader.ReadToEnd();
}
string plainTextObjectData;
plainTextObjectData = encryptionProvider.Decrypt(rawFileData, encryptionInfo);
Database db = objectSerializationProvider.Deserialize <Database>(plainTextObjectData);
return(db);
}
public ClientLicense GetClientLicense(string filePath)
{
if (File.Exists(filePath) == false)
{
return(null);
}
string rawFileData;
using (StreamReader reader = new StreamReader(filePath))
{
rawFileData = reader.ReadToEnd();
}
string plainTextObjectData;
plainTextObjectData = encryptionProvider.Decrypt(rawFileData, encryptionInfo);
ClientLicense sl = objectSerializationProvider.Deserialize <ClientLicense>(plainTextObjectData);
return(sl);
}
public string InitializeService(string token, string data)
{
InitializationResult result = new InitializationResult();
try
{
if (!_controlService.ValidateManagementToken(token))
{
result.WasInitializionSucessful = false;
return(_controlService.EncryptSymmetricResponse(_serializationProvider.Serialize(result)));
}
string decryptedData = _controlService.DecryptSymmetricResponse(data);
MasterServiceData masterData = _serializationProvider.Deserialize <MasterServiceData>(decryptedData);
MasterServiceData masterData1 = _masterService.SetMasterServiceData(masterData);
if (masterData1 == null)
{
result.WasInitializionSucessful = false;
return(_controlService.EncryptSymmetricResponse(_serializationProvider.Serialize(result)));
}
result.WasInitializionSucessful = true;
string path = _commonService.GetPath();
if (File.Exists(path + "\\AllowDatabaseTest.emp"))
{
File.Delete(path + "\\AllowDatabaseTest.emp");
}
}
catch (Exception ex)
{
LoggingHelper.LogException(ex);
}
return(_controlService.EncryptSymmetricResponse(_serializationProvider.Serialize(result)));
}