//Read Registry
public string RegistryReadr(string subKey,string keyName)
{
try
{
RegistryPermission regeditPermission = new RegistryPermission(RegistryPermissionAccess.Read, System.IO.Path.Combine(Registry.CurrentUser.ToString(), System.IO.Path.Combine(ProcestaVariables.Variables.REGISTRY_PATH, subKey)));
regeditPermission.Demand();
RegistryKey regeditRead = Registry.CurrentUser;
regeditRead = regeditRead.OpenSubKey(System.IO.Path.Combine(ProcestaVariables.Variables.REGISTRY_PATH, subKey));
if (regeditRead != null)
{
if ((regeditRead.GetValue(keyName)).GetType().Equals(typeof(Int32)))
{
return regeditRead.GetValue(keyName).ToString();
}
else
{
return (string)regeditRead.GetValue(keyName);
}
}
else
{
RegistryWriter(subKey,keyName,string.Empty,RegistryValueKind.String);
RegistryReadr(subKey, keyName);
return null;
}
}
catch (Exception)
{
MessageBox.Show(ProcestaVariables.Variables.ERROR_MESSAGES[0,4], ProcestaVariables.Variables.ERROR_MESSAGES[0,0], MessageBoxButtons.OK, MessageBoxIcon.Error);
return null;
}
}
/// <summary>
/// Call this function before creating the RegistryUtils class in order to make sure that
/// you (the caller) will have permissions to access the class.
/// </summary>
/// <param name="subKey">
/// The sub key to demand permissions for.
/// </param>
public static void DemandLocalMachineAccess(string subKey)
{
// Create permission objects for the registry keys we're about to use.
RegistryPermission readPermissions = new RegistryPermission(RegistryPermissionAccess.Read, @"HKEY_LOCAL_MACHINE\" + subKey);
// Now force this function to throw a SecurityException if we don't already have these permissions.
readPermissions.Demand();
}
private void CheckSecurity()
{
//check registry permissions
RegistryPermission regPerm;
regPerm = new RegistryPermission(RegistryPermissionAccess.Write, "HKEY_CLASSES_ROOT\\" + MenuName);
regPerm.AddPathList(RegistryPermissionAccess.Write, "HKEY_CLASSES_ROOT\\" + Command);
regPerm.Demand();
}
/// <summary>
/// Call this function before creating the RegistryUtils class in order to make sure that
/// you (the caller) will have permissions to access the class.
/// </summary>
/// <param name="subKey">
/// The sub key to demand permissions for.
/// </param>
public static void DemandCurrentUserAccess(string subKey)
{
// Create permission objects for the registry keys we're about to use.
RegistryPermission fullPermissions = new RegistryPermission(RegistryPermissionAccess.AllAccess, @"HKEY_CURRENT_USER\" + subKey);
// Now force this function to throw a SecurityException if we don't already have these permissions.
fullPermissions.Demand();
}
/// <summary>
/// Creates a new WebTransform.
/// </summary>
public WebTransform()
{
//[IsolatedStorageFilePermissionAttribute(SecurityAction.Demand, Unrestricted=true)]
FileIOPermission filePerm = new FileIOPermission(PermissionState.None);
RegistryPermission regPerm = new RegistryPermission(PermissionState.None);
filePerm.Demand();
regPerm.Demand();
}
/// <summary>
/// Call this function before creating the RegistryUtils class in order to make sure that
/// you (the caller) will have permissions to access the class.
/// </summary>
public static void Demand()
{
// Create permission objects for the registry keys we're about to use.
string fullRegistryPath = @"HKEY_CURRENT_USER\Software\Microsoft\" + ApplicationAcronym;
RegistryPermission fullPermissions =
new RegistryPermission(RegistryPermissionAccess.AllAccess, fullRegistryPath);
// Now force this function to throw a SecurityException if we don't already have these permissions.
fullPermissions.Demand();
}
public static bool HavePermissionsOnKey(this RegistryPermission reg, RegistryPermissionAccess accessLevel, string key)
{
try
{
RegistryPermission r = new RegistryPermission(accessLevel, key);
r.Demand();
return true;
}
catch (SecurityException)
{
return false;
}
}
public static bool CanReadKey(this RegistryPermission reg, string key)
{
try
{
RegistryPermission r = new RegistryPermission(RegistryPermissionAccess.Read, key);
r.Demand();
return true;
}
catch (SecurityException)
{
return false;
}
}
protected bool HavePermissionsOnKey(RegistryPermissionAccess accessLevel, string key)
{
try
{
RegistryPermission r = new RegistryPermission(accessLevel, key);
r.Demand();
return true;
}
catch (SecurityException)
{
return false;
}
}
/// <summary>
/// check the read permission has the registry
/// </summary>
/// <param name="registry">SOFTWARE\\Wow6432Node\\LibreOffice\\UNO\\InstallPath</param>
/// <returns>true or false</returns>
public static bool RegistryCanRead(string registry)
{
bool isPermission;
try
{
RegistryPermission perm1 = new RegistryPermission(RegistryPermissionAccess.Read, registry);
perm1.Demand();
isPermission = true;
}
catch (System.Security.SecurityException ex)
{
isPermission = false;
}
return isPermission;
}
//Write Registry Value
public bool RegistryWriter(string subKey, string keyName,string keyValue, RegistryValueKind valueType)
{
try
{
RegistryPermission regeditPermission = new RegistryPermission(RegistryPermissionAccess.AllAccess,System.IO.Path.Combine(Registry.CurrentUser.ToString(),System.IO.Path.Combine(ProcestaVariables.Variables.REGISTRY_PATH,subKey)));
regeditPermission.Demand();
RegistryKey regeditWrite=Registry.CurrentUser;
//regeditWrite.SetAccessControl(regeditUserRuls);
regeditWrite = regeditWrite.OpenSubKey(System.IO.Path.Combine(ProcestaVariables.Variables.REGISTRY_PATH, subKey), true);
if(regeditWrite!=null)
{
if(valueType.Equals(RegistryValueKind.Binary))
{
regeditWrite.SetValue(keyName,RegeditNecessaryFunction.ToByteArray(keyValue),RegistryValueKind.Binary);
regeditWrite.Close();
return true;
}
else if(valueType.Equals(RegistryValueKind.DWord))
{
regeditWrite.SetValue(keyName,Convert.ToInt32(keyValue),RegistryValueKind.DWord);
regeditWrite.Close();
return true;
}
else if( valueType.Equals(RegistryValueKind.ExpandString))
{
regeditWrite.SetValue(keyName,keyValue,RegistryValueKind.ExpandString);
regeditWrite.Close();
return true;
}
else if(valueType.Equals(RegistryValueKind.MultiString))
{
regeditWrite.SetValue(keyName,RegeditNecessaryFunction.ToStringArray(keyValue),RegistryValueKind.MultiString);
regeditWrite.Close();
return true;
}
else if(valueType.Equals(RegistryValueKind.QWord))
{
regeditWrite.SetValue(keyName,Convert.ToInt32(keyValue),RegistryValueKind.QWord);
regeditWrite.Close();
return true;
}
else
{
regeditWrite.SetValue(keyName,keyValue,RegistryValueKind.String);
regeditWrite.Close();
return true;
}
}
else
{
RegistryKey regKeyCrator=Registry.CurrentUser;
regKeyCrator = regKeyCrator.CreateSubKey(System.IO.Path.Combine(ProcestaVariables.Variables.REGISTRY_PATH, subKey), RegistryKeyPermissionCheck.Default);
regKeyCrator.Close();
RegistryWriter(subKey,keyName,keyValue,valueType);
return true;
}
}
catch (Exception e)
{
MessageBox.Show(ProcestaVariables.Variables.ERROR_MESSAGES[0,3] + Environment.NewLine + e, ProcestaVariables.Variables.ERROR_MESSAGES[0,0], MessageBoxButtons.OK, MessageBoxIcon.Stop);
return false;
}
}
internal void SetAppKey(string AppName)
{
try
{
//SubKeys.SawyerHklmName = @topLevel;
//SubKeys.SawyerHkcuName = @topLevel;
SawyerHklmName = @topLevel;
SawyerHkcuName = @topLevel;
AppHklmName = @topLevel + @"\" + AppName;
AppHklmName = @topLevel + @"\" + AppName;
string
hklm = @"HKEY_LOCAL_MACHINE\",
hkcu = @"HKEY_CURRENT_USER\";
regPerm = new RegistryPermission(PermissionState.Unrestricted);
regPerm.AddPathList(RegistryPermissionAccess.AllAccess,
hklm + topLevel + ";" +
hklm + topLevel + @"\" + AppName + ";" +
hkcu + topLevel + ";" +
hkcu + topLevel + @"\" + AppName);
regPerm.Demand();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
//store: root, subkey, value, path, id
//scandata: key root, string key, string value, string path, string img, string name, int scope, int id
void StoreResults(cLightning.ROOT_KEY root, string subkey, string value, string data, RESULT_TYPE id)
{
// ****************************************************
// Trying to check registry key permissions
// ****************************************************
try
{
var permission = new RegistryPermission(RegistryPermissionAccess.Write, root.ToString());
permission.Demand();
}
catch (System.Security.SecurityException ex)
{
return;
}
// ****************************************************
// Trying to check registry key permissions
// ****************************************************
if (_oProcessAsyncBackgroundWorker != null && _oProcessAsyncBackgroundWorker.CancellationPending)
{
return;
}
int i = (int)id;
if (value.Length == 0)
{
value = STR_DEFAULT;
}
Data.Add(new ScanData(root, subkey, value, data, "", IdConverter(id), IdToScope(i), i));
// notify
MatchItem(root, subkey, value, data, id);
}
internal void ClassicRegistration(Assembly asm)
{
RegistryPermission permission = new RegistryPermission(PermissionState.Unrestricted);
permission.Demand();
permission.Assert();
try
{
new RegistrationServices().RegisterAssembly(asm, AssemblyRegistrationFlags.SetCodeBase);
}
catch (Exception exception)
{
if ((exception is NullReferenceException) || (exception is SEHException))
{
throw;
}
throw new RegistrationException(Resource.FormatString("Reg_AssemblyRegErr", asm), exception);
}
}
//check if we have access to the startUp key
private static bool checkWritableKey()
{
try
{
RegistryPermission r = new RegistryPermission(RegistryPermissionAccess.Write, @"SOFTWARE\Microsoft\Windows\CurrentVersion\Run");
r.Demand();
return true;
}
catch (SecurityException)
{
return false;
}
}
private static void set_key_permissions(string keyPath)
{
RegistryPermission regPermission = new RegistryPermission(RegistryPermissionAccess.AllAccess, keyPath);
regPermission.Demand();
}
static WindowsTimeZone()
{
RegistryPermission permission = new RegistryPermission(
RegistryPermissionAccess.Read,
"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Time Zones");
try
{
permission.Demand();
timeZones = LoadTimeZonesFromRegistry();
}
catch //(Exception ex) //If we can't get into the Registry for any reason, try the fallback...
{
//SDH: Requires FullTrust
//System.Diagnostics.Debug.WriteLine("Error: LoadTimeZonesFromRegistry " + ex.ToString());
timeZones = LoadTimeZonesFromXml();
}
}
private void Load( RegistryKey root )
{
{
string pathList = root.ToString();
var permission = new RegistryPermission( RegistryPermissionAccess.Read,
AccessControlActions.View,
pathList );
permission.Demand();
}
IEnumerable<IConfigurationSection> sections = GetSections( root );
sections.ToList().ForEach( Add );
}
private void checkRegistryPermissions()
{
try
{
RegistryPermission perm;
perm = new RegistryPermission(RegistryPermissionAccess.Write, regPath);
perm.Demand();
}
catch (Exception ex)
{
MessageBox.Show(this, "Error while requesting permission for registry I/O: \r\n" + ex.ToString());
}
}