/// <summary>
/// Encrypts the data in a specified byte array and returns a byte array that contains the encrypted data.
/// This method uses the local machine account.
/// </summary>
/// <param name="data">The data to protect.</param>
/// <returns>The stream containing the protected data.</returns>
public MemoryStream MachineProtect(byte[] data)
{
DataProtection protect = new DataProtection();
byte[] protectedData = protect.Protect(data, DataProtectionScope.LocalMachine);
return(new MemoryStream(protectedData));
}
public static bool CheckUserCookie(UserProfile profile)
{
if (HttpContext.Current.Request.Cookies["UserProfileCookie"] != null)
{
string strId = DataProtection.Decrypt(HttpContext.Current.Request.Cookies["UserProfileCookie"]["Id"]);
if (string.IsNullOrWhiteSpace(strId))
{
return(false);
}
UserModel employee = new CU_AccountService().ValidateLoginData(DataProtection.Decrypt(HttpContext.Current.Request.Cookies["UserProfileCookie"]["LoginName"])
, DataProtection.Decrypt(HttpContext.Current.Request.Cookies["UserProfileCookie"]["Password"]));
if (employee != null)
{
CreateUserSession(profile, employee);
return(true);
}
else
{
return(false);
}
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Decrypts the data in a specified byte array and returns a byte array that contains the decrypted data.
/// This method uses the current user account.
/// </summary>
/// <param name="data">The data to unprotect.</param>
/// <returns>The stream containing the unprotected data.</returns>
public MemoryStream UserUnprotect(byte[] data)
{
DataProtection unprotect = new DataProtection();
byte[] unprotectedData = unprotect.Unprotect(data, DataProtectionScope.CurrentUser);
return(new MemoryStream(unprotectedData));
}
public async Task ExecuteAsync()
{
try
{
var content = new StringContent(JsonConvert.SerializeObject(_infoModel), Encoding.UTF8, "application/json");
var request = new HttpRequestMessage()
{
RequestUri = new Uri("Agent/Report/", UriKind.Relative),
Method = HttpMethod.Post,
Content = content
};
CertHandler _certHandler = new CertHandler();
X509Certificate2 clientCertificate = _certHandler.FindCertificate("YaraCA", StoreName.My, StoreLocation.LocalMachine);
request.Headers.Add("X-ARR-ClientCert", clientCertificate.GetRawCertDataString());
var response = await HttpClientSingleton.HttpClientInstance.SendAsync(request);
response.EnsureSuccessStatusCode();
}
catch (HttpRequestException)
{
string timestamp = Guid.NewGuid().ToString();
string infoModelString = JsonConvert.SerializeObject(_infoModel);
byte[] infoModelEnc = DataProtection.Protect(Encoding.UTF8.GetBytes(infoModelString));
FileHandler.WriteBytesToFile(FileHandler.REPORT_ARCHIVE + timestamp, infoModelEnc);
}
}
internal static DatabaseInfo PromptForInfo(EFCorePowerToolsPackage package)
{
// Show dialog with SqlClient selected by default
var dialogFactory = package.GetService <IVsDataConnectionDialogFactory>();
var dialog = dialogFactory.CreateConnectionDialog();
dialog.AddAllSources();
dialog.SelectedSource = new Guid("067ea0d9-ba62-43f7-9106-34930c60c528");
var dialogResult = dialog.ShowDialog(connect: true);
if (dialogResult == null)
{
return new DatabaseInfo {
DatabaseType = DatabaseType.Undefined
}
}
;
var info = GetDatabaseInfo(package, dialogResult.Provider, DataProtection.DecryptString(dialog.EncryptedConnectionString));
if (info.Size == Guid.Empty.ToString())
{
return new DatabaseInfo {
DatabaseType = DatabaseType.Undefined
}
}
;
SaveDataConnection(package, dialog.EncryptedConnectionString, info.DatabaseType, new Guid(info.Size));
return(info);
}
internal static void RemoveDataConnection(SqlCeToolboxPackage package, string connectionString, Guid provider)
{
var removals = new List <IVsDataExplorerConnection>();
var dataExplorerConnectionManager = package.GetServiceHelper(typeof(IVsDataExplorerConnectionManager)) as IVsDataExplorerConnectionManager;
if (dataExplorerConnectionManager != null)
{
foreach (var connection in dataExplorerConnectionManager.Connections.Values)
{
var objProviderGuid = connection.Provider;
if ((objProviderGuid == new Guid(Resources.SqlCompact35Provider)) || (objProviderGuid == new Guid(Resources.SqlCompact40Provider)))
{
if (DataProtection.DecryptString(connection.EncryptedConnectionString) == connectionString)
{
removals.Add(connection);
}
}
}
for (int i = removals.Count - 1; i >= 0; i--)
{
try
{
dataExplorerConnectionManager.RemoveConnection(removals[i]);
}
catch (ArgumentException)
{
}
catch (IndexOutOfRangeException)
{
}
}
}
}
/// <summary>
/// Creates and returns a fully configured <see cref="ILogProvider"/> instance.
/// </summary>
/// <returns>A fully configured <see cref="ILogProvider"/> instance.</returns>
public ILogProvider GetConfiguredInstance()
{
if (!string.IsNullOrEmpty(txtUrl.Text))
{
if (ModifierKeys != Keys.Shift)
{
// Save the current settings as new default values.
Settings.Default.PnlCustomHttpSettingsUrl = txtUrl.Text;
Settings.Default.PnlCustomHttpSettingsAuthentication = chkAuthentication.Checked;
Settings.Default.PnlCustomHttpSettingsUsername = DataProtection.EncryptString(txtUsername.Text);
Settings.Default.PnlCustomHttpSettingsPassword = DataProtection.EncryptString(txtPassword.Text);
Settings.Default.PnlCustomHttpSettingsPollTime = (int)nudPollingTime.Value;
Settings.Default.PnlCustomTcpSettingsEncoding = ((EncodingWrapper)cmbEncoding.SelectedItem).Codepage;
if (cmbColumnizer.SelectedItem != null)
{
Settings.Default.PnlCustomHttpSettingsColumnizer = cmbColumnizer.SelectedItem.ToString();
}
Settings.Default.SaveSettings();
}
return(new CustomHttpReceiver(
txtUrl.Text
, chkAuthentication.Checked ? new BasicHttpAuthentication(txtUsername.Text, txtPassword.Text) : null
, (int)nudPollingTime.Value
, cmbColumnizer.SelectedItem as Columnizer
, Settings.Default.PnlCustomHttpSettingsEncoding));
}
return(null);
}
public void ObtainFromDB()
{
using (SQLiteConnection myconnection = new SQLiteConnection(SystemParameters.ConnectionString))
{
myconnection.Open();
using (SQLiteCommand mycommand = new SQLiteCommand(myconnection))
{
mycommand.CommandText = String.Format("SELECT * FROM {0}", tableName);
SQLiteDataReader dataReader = mycommand.ExecuteReader();
if (dataReader.Read())
{
if (dataReader["syncable"].ToString().Equals("1"))
{
this.syncable = 1;
}
else
{
this.syncable = 0;
}
this.account = dataReader["account"].ToString();
this.password = DataProtection.Decrypt(dataReader["password"].ToString());
this.url = dataReader["url"].ToString();
this.apiKey = DataProtection.Decrypt(dataReader["api_key"].ToString());
this.rootFolderPath = dataReader["root_folder_path"].ToString();
this.displayName = dataReader["display_name"].ToString();
this.defaultOrganizationResourceID = dataReader["default_organization_resource_id"].ToString();
this.defaultLicenseResourceID = dataReader["default_license_resource_id"].ToString();
}
}
myconnection.Close();
}
}
public List <string> ReadConnection(string id)
{
var connectionList = new List <string>();
var data = new DataProtection();
try
{
var root = XElement.Load(@".\Config\Connections.xml");
var connection =
from el in root.Elements("Connection")
where (string)el.Attribute("ID") == id
select el;
foreach (var el in connection)
{
connectionList.Add(data.Decrpyt(el.Element("Address").Value));
connectionList.Add(data.Decrpyt(el.Element("Username").Value));
connectionList.Add(data.Decrpyt(el.Element("Password").Value));
connectionList.Add(data.Decrpyt(el.Element("Database").Value));
}
return(connectionList);
}
catch (Exception e)
{
Log.Error("Unable to read connection. " + e.Message);
}
return(null);
}
public void SaveConnection(List <string> value)
{
var data = new DataProtection();
try
{
var fileDir = XDocument.Load(@".\Config\Connections.xml");
var newConnection = new XElement("Connection",
new XElement("Address", data.Encrpyt(value[0])),
new XElement("Username", data.Encrpyt(value[1])),
new XElement("Password", data.Encrpyt(value[2])),
new XElement("Database", data.Encrpyt(value[3]))
);
newConnection.SetAttributeValue("ID", value[4]);
newConnection.SetAttributeValue("Default", value[5]);
var xElement = fileDir.Element("Connections");
if (xElement != null)
{
xElement.Add(newConnection);
}
fileDir.Save(@".\Config\Connections.xml");
}
catch (Exception e)
{
Log.Error("Unable to save connection. " + e.Message);
}
}
// Scanner Listener
public void OnFileScanned(InfoModel report)
{
// Check not send reports
List <NetScanJob> netScanJobs = new List <NetScanJob>();
foreach (string file in Directory.EnumerateFiles(FileHandler.REPORT_ARCHIVE))
{
try
{
byte[] encReport = FileHandler.ReadTextFromFile(file);
byte[] decReport = DataProtection.Unprotect(encReport);
string content = Encoding.UTF8.GetString(decReport);
InfoModel infoModel = JsonConvert.DeserializeObject <InfoModel>(content);
NetScanJob netScanJob = new NetScanJob(report);
netScanJobs.Add(netScanJob);
FileHandler.DeleteFile(file);
}
catch (Exception ex)
{
}
}
netScanJobs.Add(new NetScanJob(report));
foreach (NetScanJob job in netScanJobs)
{
mNetworking.ExecuteAsync(job);
}
}
public void GenerateServerDgmlFiles()
{
try
{
if (_package.Dte2.Mode == vsIDEMode.vsIDEModeDebug)
{
EnvDteHelper.ShowError("Cannot generate code while debugging");
return;
}
// Show dialog with SqlClient selected by default
var dialogFactory = _package.GetService <IVsDataConnectionDialogFactory>();
var dialog = dialogFactory.CreateConnectionDialog();
dialog.AddAllSources();
dialog.SelectedSource = new Guid("067ea0d9-ba62-43f7-9106-34930c60c528");
var dialogResult = dialog.ShowDialog(connect: true);
if (dialogResult == null)
{
return;
}
_package.Dte2.StatusBar.Text = "Loading schema information...";
var dbInfo = GetDatabaseInfo(dialogResult, DataProtection.DecryptString(dialog.EncryptedConnectionString));
if (dbInfo.DatabaseType == DatabaseType.SQLCE35)
{
EnvDteHelper.ShowError($"Unsupported provider: {dbInfo.ServerVersion}");
return;
}
var ptd = new PickTablesDialog();
using (var repository = RepositoryHelper.CreateRepository(dbInfo))
{
ptd.Tables = repository.GetAllTableNamesForExclusion();
}
var res = ptd.ShowModal();
if (!res.HasValue || !res.Value)
{
return;
}
var path = Path.GetTempFileName() + ".dgml";
using (var repository = RepositoryHelper.CreateRepository(dbInfo))
{
var generator = RepositoryHelper.CreateGenerator(repository, path, dbInfo.DatabaseType);
generator.GenerateSchemaGraph(dbInfo.ConnectionString, ptd.Tables);
_package.Dte2.ItemOperations.OpenFile(path);
_package.Dte2.ActiveDocument.Activate();
}
}
catch (Exception ex)
{
_package.LogError(new List <string>(), ex);
}
}
internal static void SaveDataConnection(EFCorePowerToolsPackage package, string encryptedConnectionString,
DatabaseType dbType, Guid provider)
{
var dataExplorerConnectionManager = package.GetService <IVsDataExplorerConnectionManager>();
var savedName = GetFileName(DataProtection.DecryptString(encryptedConnectionString), dbType);
dataExplorerConnectionManager.AddConnection(savedName, provider, encryptedConnectionString, true);
}
public static Tuple <string, string> setNewAgentPassword(SecureString new_password)
{
/* With the given password return the corresponding hash with a new salt (which will have to be saved into the database)*/
string salt = DataProtection.getSaltForHashes();
string hashed_password = DataProtection.getSaltHashedString(new_password, salt);
return(Tuple.Create(hashed_password, salt));
}
public async Task <bool> RunAsync(string emailAddress)
{
HashSet emailAddressHash = await DataProtection.StaticHashAsync(emailAddress, DataKeys.EmailAddressSalt);
return(await _authenticationDbContext.Identities
.AnyAsync(i => i.AuthenticationIdentities.OfType <PasswordIdentity>()
.Any(a => a.EmailAddressHash == emailAddressHash.Hash)
));
}
internal static void SaveDataConnection(SqlCeToolboxPackage package, string encryptedConnectionString,
DatabaseType dbType, Guid provider)
{
if (package.GetServiceHelper(typeof(IVsDataExplorerConnectionManager)) is IVsDataExplorerConnectionManager dataExplorerConnectionManager)
{
var savedName = GetFileName(DataProtection.DecryptString(encryptedConnectionString), dbType);
dataExplorerConnectionManager.AddConnection(savedName, provider, encryptedConnectionString, true);
}
}
private void save_button_Click(object sender, EventArgs e)
{
if (mail_adress_textBox.Text == "" || password_textBox.Text == "" || smtp_port_textBox.Text == "" || smtp_port_textBox.Text == "")
{
MessageBox.Show("ERREUR : tous les champs doivent être renseignés !");
return;
}
Parms parms = new Parms();
parms.toDefault();
parms.adress = mail_adress_textBox.Text;
parms.smtpSever = smtp_server_textBox.Text;
try
{
parms.smtpPort = Int32.Parse(smtp_port_textBox.Text);
}
catch
{
MessageBox.Show("ERREUR : format du port SMTP non reconnu");
return;
}
if (password_textBox.Text != DISPLAY_PASSWORD) //new password, so have to change it
{
SecureString password = new SecureString();
foreach (char c in password_textBox.Text)
{
password.AppendChar(c);
}
password.MakeReadOnly();
try
{
parms.password = DataProtection.protect(password);
}
catch
{
MessageBox.Show("ERREUR : Impossible de sécuriser le mot de passe avant de l'enregistrer");
return;
}finally
{
password.Dispose();
}
}//else password reamin the same (already saved in the sruct ParmsMailsSender)
parms.beforeMessage = removeAllVoidAtTheExtremaOfString(before_message_textBox.Text).Replace(Environment.NewLine, "<br>");
parms.afterMessage = removeAllVoidAtTheExtremaOfString(after_message_textBox.Text).Replace(Environment.NewLine, "<br>");
ToolsClass.Settings.MailsSenderParameters = parms;
this.Close();
}
/// <summary>
/// Raises the <see cref="E:System.Windows.Forms.UserControl.Load"/> event.
/// </summary>
/// <param name="e">An <see cref="T:System.EventArgs"/> that contains the event data. </param>
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
cmbColumnizer.Items.AddRange(LoadColumnizer());
if (cmbColumnizer.Items.Count > 0)
{
if (ModifierKeys != Keys.Shift)
{
foreach (var columnizer in cmbColumnizer.Items)
{
if (Equals(columnizer.ToString(), Settings.Default.PnlCustomHttpSettingsColumnizer))
{
cmbColumnizer.SelectedItem = columnizer;
break;
}
}
}
if (cmbColumnizer.SelectedItem == null)
{
cmbColumnizer.SelectedIndex = 0;
}
}
if (ModifierKeys != Keys.Shift)
{
txtUrl.Text = Settings.Default.PnlCustomHttpSettingsUrl;
txtUsername.Text = DataProtection.DecryptString(Settings.Default.PnlCustomHttpSettingsUsername);
txtPassword.Text = DataProtection.DecryptString(Settings.Default.PnlCustomHttpSettingsPassword);
chkAuthentication.Checked = Settings.Default.PnlCustomHttpSettingsAuthentication;
nudPollingTime.Value = Settings.Default.PnlCustomHttpSettingsPollTime;
}
foreach (EncodingInfo encoding in Encoding.GetEncodings())
{
EncodingWrapper encWrapper = new EncodingWrapper(encoding);
cmbEncoding.Items.Add(encWrapper);
if (encoding.CodePage == (ModifierKeys != Keys.Shift ? Settings.Default.PnlCustomTcpSettingsEncoding : Encoding.Default.CodePage))
{
cmbEncoding.SelectedItem = encWrapper;
}
}
if (cmbEncoding.SelectedItem == null)
{
cmbEncoding.SelectedIndex = 0;
}
UpdateEditButtons();
}
private async Task <List <TableModel> > GetTablesAsync(DatabaseConnectionModel dbInfo, CodeGenerationMode codeGenerationMode, SchemaInfo[] schemas)
{
if (dbInfo.DataConnection != null)
{
dbInfo.DataConnection.Open();
dbInfo.ConnectionString = DataProtection.DecryptString(dbInfo.DataConnection.EncryptedConnectionString);
}
var builder = new TableListBuilder(dbInfo.ConnectionString, dbInfo.DatabaseType, schemas);
return(await builder.GetTableDefinitionsAsync(codeGenerationMode));
}
public async Task <Identity> RunAsync(
AuthenticationGrantTypeClientCredential authenticationGrantTypeClientCredential,
string identifier)
{
HashSet identifierHash = await DataProtection.StaticHashAsync(identifier, DataKeys.IdentifierSalt);
return(await _authenticationDbContext.Identities
.SingleOrDefaultAsync(i =>
i.AuthenticationIdentities.OfType <ClientCredentialIdentity>().Any(a =>
a.IdentifierHash == identifierHash.Hash &&
a.AuthenticationGrantTypeClientCredential == authenticationGrantTypeClientCredential)));
}
public List <TableInformationModel> GetTables(DatabaseInfo dbInfo, bool useEFCore5, SchemaInfo[] schemas)
{
if (dbInfo.DataConnection != null)
{
dbInfo.DataConnection.Open();
dbInfo.ConnectionString = DataProtection.DecryptString(dbInfo.DataConnection.EncryptedConnectionString);
}
var builder = new TableListBuilder(dbInfo.ConnectionString, dbInfo.DatabaseType, schemas);
return(builder.GetTableDefinitions(useEFCore5));
}
public static List <TableInformationModel> GetTablesFromRepository(DatabaseInfo dbInfo, bool includeViews = false)
{
if (dbInfo.DataConnection != null)
{
dbInfo.DataConnection.Open();
dbInfo.ConnectionString = DataProtection.DecryptString(dbInfo.DataConnection.EncryptedConnectionString);
}
if (dbInfo.DatabaseType == DatabaseType.Npgsql)
{
return(EnvDteHelper.GetNpgsqlTableNames(dbInfo.ConnectionString, includeViews));
}
if (dbInfo.DatabaseType == DatabaseType.Mysql)
{
return(EnvDteHelper.GetMysqlTableNames(dbInfo.ConnectionString, includeViews));
}
if (dbInfo.DatabaseType == DatabaseType.Oracle)
{
return(EnvDteHelper.GetOracleTableNames(dbInfo.ConnectionString, includeViews));
}
using (var repository = RepositoryHelper.CreateRepository(dbInfo))
{
var allPks = repository.GetAllPrimaryKeys();
var tableList = repository.GetTableNamesForExclusion();
var tables = new List <TableInformationModel>();
foreach (var table in tableList)
{
var hasPrimaryKey = allPks.Any(m => m.TableName == table.TableName);
var name = string.IsNullOrEmpty(table.Schema)
? table.TableName
: $"[{table.Schema}].[{table.Name}]";
var info = new TableInformationModel(name, includeViews ? true : hasPrimaryKey, includeViews ? !hasPrimaryKey : false);
tables.Add(info);
}
if (includeViews)
{
var views = repository.GetAllViews();
foreach (var view in views)
{
var info = new TableInformationModel(view.ViewName, true, true);
tables.Add(info);
}
}
return(tables.OrderBy(l => l.Name).ToList());
}
}
private async Task <List <TableModel> > GetTablesAsync(DatabaseInfo dbInfo, bool useEFCore5, SchemaInfo[] schemas)
{
if (dbInfo.DataConnection != null)
{
dbInfo.DataConnection.Open();
dbInfo.ConnectionString = DataProtection.DecryptString(dbInfo.DataConnection.EncryptedConnectionString);
}
var builder = new TableListBuilder(dbInfo.ConnectionString, dbInfo.DatabaseType, schemas);
return(await System.Threading.Tasks.Task.Run(() => builder.GetTableDefinitions(useEFCore5)));
}
public async Task StoreAsync <T>(string key, T value)
{
StorageFile file = await LocalFolder.CreateFileAsync(GenerateStoredKey(key, typeof(T)),
CreationCollisionOption.ReplaceExisting);
var content = NewtonsoftJsonSerializer.Instance.Serialize(value);
byte[] protectedContent = DataProtection.Protect(content);
using (var stream = await file.OpenStreamForWriteAsync().ConfigureAwait(false))
{
await stream.WriteAsync(protectedContent, 0, protectedContent.Length).ConfigureAwait(false);
}
}
private static Guid GetVsDataSource(IVsDataProviderManager dataProviderManager, IVsDataConnection dataConnection)
{
if (dataConnection == null)
{
throw new ArgumentNullException("dataConnection");
}
var guid = Guid.Empty;
var provider = GetVsProvider(dataProviderManager, dataConnection);
guid = provider.DeriveSource(DataProtection.DecryptString(dataConnection.EncryptedConnectionString));
return(guid);
}
internal static void SaveDataConnection(string connectionString, DatabaseType dbType,
SqlCeToolboxPackage package)
{
var storeDbType = GetPreferredDatabaseType();
var helper = CreateEngineHelper(storeDbType);
string path = CreateEngineHelper(dbType).PathFromConnectionString(connectionString);
helper.SaveDataConnection(CreateStore(storeDbType), connectionString, path, dbType.GetHashCode());
if (package.VsSupportsSimpleDdex4Provider() && dbType == DatabaseType.SQLCE40)
{
SaveDataConnection(package, DataProtection.EncryptString(connectionString), dbType,
new Guid(Resources.SqlCompact40PrivateProvider));
}
}
public string UnsecureDecrypt(byte[] value)
{
if (value == null || value.Length == 0)
{
return(string.Empty);
}
byte[] pw = DataProtection.Unprotect(value);
char[] chars = new char[pw.Length / sizeof(char)];
Buffer.BlockCopy(pw, 0, chars, 0, pw.Length);
return(new string(chars));
}
public static void CreateUserCookie(UserProfile profile, UserModel employee, string password = null)
{
var cookie = new HttpCookie("UserProfileCookie");
cookie["Id"] = DataProtection.Encrypt(profile.Id.ToString());
cookie["Name"] = DataProtection.Encrypt(profile.Name);
cookie["LoginName"] = DataProtection.Encrypt(profile.LoginName);
cookie["Password"] = DataProtection.Encrypt(password);
cookie["Email"] = DataProtection.Encrypt(profile.Email);
cookie["LastVisitTime"] = DataProtection.Encrypt(profile.LastVisitTime);
cookie["BranchID"] = DataProtection.Encrypt(profile.BranchID.ToString());
cookie.Expires = DateTime.Now.AddDays(7);
HttpContext.Current.Response.Cookies.Add(cookie);
}
public async Task <T> GetAsync <T>(string key)
{
byte[] content = await ReadFileContentAsync(GenerateStoredKey(key, typeof(T))).ConfigureAwait(false);
TaskCompletionSource <T> tcs = new TaskCompletionSource <T>();
if (content.Length == 0)
{
return(default(T));
}
var data = DataProtection.Unprotect(content);
return(NewtonsoftJsonSerializer.Instance.Deserialize <T>(data));
}
public RdpConfig(string address, string username, string password)
{
if (string.IsNullOrEmpty(address))
{
throw new ArgumentNullException(nameof(address));
}
FullAddress = address;
Username = username;
if ((password ?? "") != "")
{
Password = BitConverter.ToString(DataProtection.ProtectData(Encoding.Unicode.GetBytes(password), "")).Replace("-", "");
}
}
