.net - seguro - Agregue sitios de confianza mediante programación a Internet Explorer

configurar un sitio como seguro

Question

Estoy haciendo un proyecto de automatización de IE usando WatiN.

Cuando se hace clic en un archivo para descargar, obtengo lo siguiente en la barra de información de Internet Explorer:

Para ayudar a proteger su seguridad, Internet Explorer ha bloqueado este sitio para que no descargue archivos a su computadora.

Para descargar el informe, puedo agregar manualmente el sitio a la lista de sitios confiables de Internet Explorer, pero preferiría verificar programáticamente en .NET para ver si el sitio es de confianza y agregarlo a la lista si no lo es.

FYI, actualmente estoy usando IE7.

Answer 1

Usar powershell es bastante fácil.

#Setting IExplorer settings
Write-Verbose "Now configuring IE"
#Add http://website.com as a trusted Site/Domain
#Navigate to the domains folder in the registry
set-location "HKCU:/Software/Microsoft/Windows/CurrentVersion/Internet Settings"
set-location ZoneMap/Domains

#Create a new folder with the website name
new-item website/ -Force
set-location website/
new-itemproperty . -Name * -Value 2 -Type DWORD -Force
new-itemproperty . -Name http -Value 2 -Type DWORD -Force
new-itemproperty . -Name https -Value 2 -Type DWORD -Force

Answer 2

Eche un vistazo a esto

Básicamente, parece que todo lo que tienes que hacer es crear la clave de registro en

HKEY_CURRENT_USER/Software/Microsoft/Windows/CurrentVersion/Internet Settings/ZoneMap/Domains/DOMAINNAME

luego un valor REG_DWORD llamado "http" con valor == 2

Answer 3

Aquí está la implementación que se me ocurrió para escribir las claves de registro en .NET.

Gracias por orientarme en la dirección correcta, Ben.

using System;
using System.Collections.Generic;
using Microsoft.Win32;


namespace ReportManagement
{
    class ReportDownloader
    {
        [STAThread]
        static void Main(string[] args)
        {

            const string domainsKeyLocation = @"Software/Microsoft/Windows/CurrentVersion/Internet Settings/ZoneMap/Domains";
            const string domain = @"newsite.com";
            const int trustedSiteZone = 0x2;

            var subdomains = new Dictionary<string, string>
                                 {
                                     {"www", "https"},
                                     {"www", "http"},
                                     {"blog", "https"},
                                     {"blog", "http"}
                                 };

            RegistryKey currentUserKey = Registry.CurrentUser;

            currentUserKey.GetOrCreateSubKey(domainsKeyLocation, domain, false);

            foreach (var subdomain in subdomains)
            {
                CreateSubdomainKeyAndValue(currentUserKey, domainsKeyLocation, domain, subdomain, trustedSiteZone);
            }

            //automation code
        }

        private static void CreateSubdomainKeyAndValue(RegistryKey currentUserKey, string domainsKeyLocation, 
            string domain, KeyValuePair<string, string> subdomain, int zone)
        {
            RegistryKey subdomainRegistryKey = currentUserKey.GetOrCreateSubKey(
                string.Format(@"{0}/{1}", domainsKeyLocation, domain), 
                subdomain.Key, true);

            object objSubDomainValue = subdomainRegistryKey.GetValue(subdomain.Value);

            if (objSubDomainValue == null || Convert.ToInt32(objSubDomainValue) != zone)
            {
                subdomainRegistryKey.SetValue(subdomain.Value, zone, RegistryValueKind.DWord);
            }
        }
    }

    public static class RegistryKeyExtensionMethods
    {
        public static RegistryKey GetOrCreateSubKey(this RegistryKey registryKey, string parentKeyLocation, 
            string key, bool writable)
        {
            string keyLocation = string.Format(@"{0}/{1}", parentKeyLocation, key);

            RegistryKey foundRegistryKey = registryKey.OpenSubKey(keyLocation, writable);

            return foundRegistryKey ?? registryKey.CreateSubKey(parentKeyLocation, key);
        }

        public static RegistryKey CreateSubKey(this RegistryKey registryKey, string parentKeyLocation, string key)
        {
            RegistryKey parentKey = registryKey.OpenSubKey(parentKeyLocation, true); //must be writable == true
            if (parentKey == null) { throw new NullReferenceException(string.Format("Missing parent key: {0}", parentKeyLocation)); }

            RegistryKey createdKey = parentKey.CreateSubKey(key);
            if (createdKey == null) { throw new Exception(string.Format("Key not created: {0}", key)); }

            return createdKey;
        }
    }
}

Answer 4

Me alegro de haber encontrado tus publicaciones. Lo único que puedo agregar a las excelentes contribuciones ya es que se usa una clave de registro diferente cada vez que el URI contiene una dirección IP, es decir, la dirección no es un nombre de dominio completamente calificado.

En este caso, debe usar un enfoque alternativo:

Imagine que deseo agregar una dirección IP a los sitios de confianza: digamos 10.0.1.13 y no me importa qué protocolo.

En HKEY_CURRENT_USER / Software / Microsoft / Windows / CurrentVersion / Internet Settings / ZoneMap / Ranges, creo una clave, por ejemplo, "Range1" y el interior que crean los siguientes valores:

Un DWORD con nombre "*" y valor 0x2 (para todos los protocolos (*) y sitio de confianza (2)) Una cadena con el nombre ": Rango" con el valor "10.0.1.13"

Answer 5

Si un sitio web pudiera agregarse a los sitios confiables, ahora eso sería malo.

No estoy del todo de acuerdo, siempre que el navegador solicite permiso al usuario, la capacidad de un sitio para agregarse a sitios confiables puede simplificar enormemente la experiencia del usuario, donde el usuario confía en el dominio y desea una visualización correcta de la página.

La alternativa es que el usuario debe acceder manualmente a las opciones de Internet para agregar el dominio, que para mis usuarios no es viable.

Estoy buscando un método php o javascript para que el sitio se agregue, ya sea a través de una API de IE, o a través del registro, como ya explicaste amablemente.

Han encontrado estas posibles soluciones hasta el momento:

• php a través de shell
• otros no puedo enumerar aquí porque no tengo suficientes puntos

Answer 6

Aquí está la implementación de agregar sitios confiables programáticamente a IE, basados ​​en el código de Even Mien. Es compatible con el nombre de dominio y la dirección IP también. La limitación es que no se puede definir un protocolo específico, sino que simplemente usa "*" para todos los protocolos.

//  Source : http://support.microsoft.com/kb/182569
static class IeTrustedSite
{
    const string DOMAINS_KEY = @"Software/Microsoft/Windows/CurrentVersion/Internet Settings/ZoneMap/Domains";
    const string RANGES_KEY = @"Software/Microsoft/Windows/CurrentVersion/Internet Settings/ZoneMap/Ranges";

    const int TRUSTED_SITE_CODE = 0x2;
    const string ALL_PROTOCOL = "*";
    const string RANGE_ADDRESS = ":Range";

    public static void AddSite(string address)
    {
        string[] segmentList = address.Split(new string[] {"."}, StringSplitOptions.None);
        if (segmentList.Length == 4)
            AddIpAddress(segmentList);
        else
            AddDomainName(segmentList);
    }

    static void AddIpAddress(string[] segmentList)
    {
        string ipAddress = segmentList[0] + "." + segmentList[1] + "." + segmentList[2] + "." + segmentList[3];
        RegistryKey rangeKey = GetRangeKey(ipAddress);

        rangeKey.SetValue(ALL_PROTOCOL, TRUSTED_SITE_CODE, RegistryValueKind.DWord);
        rangeKey.SetValue(RANGE_ADDRESS, ipAddress, RegistryValueKind.String);
    }

    static RegistryKey GetRangeKey(string ipAddress)
    {
        RegistryKey currentUserKey = Registry.CurrentUser;
        for (int i = 1; i < int.MaxValue; i++)
        {
            RegistryKey rangeKey = currentUserKey.GetOrCreateSubKey(RANGES_KEY, "Range" + i.ToString());

            object addressValue = rangeKey.GetValue(RANGE_ADDRESS);
            if (addressValue == null)
            {
                return rangeKey;
            }
            else
            {
                if (Convert.ToString(addressValue) == ipAddress)
                    return rangeKey;
            }
        }
        throw new Exception("No range slot can be used.");
    }

    static void AddDomainName(string[] segmentList)
    {
        if (segmentList.Length == 2)
        {
            AddTwoSegmentDomainName(segmentList);
        }
        else if (segmentList.Length == 3)
        {
            AddThreeSegmentDomainName(segmentList);
        }
        else
        {
            throw new Exception("Un-supported server address.");
        }
    }

    static void AddTwoSegmentDomainName(string[] segmentList)
    {
        RegistryKey currentUserKey = Registry.CurrentUser;

        string domain = segmentList[0] + "." + segmentList[1];
        RegistryKey trustedSiteKey = currentUserKey.GetOrCreateSubKey(DOMAINS_KEY, domain);

        SetDomainNameValue(trustedSiteKey);
    }

    static void AddThreeSegmentDomainName(string[] segmentList)
    {
        RegistryKey currentUserKey = Registry.CurrentUser;

        string domain = segmentList[1] + "." + segmentList[2];
        currentUserKey.GetOrCreateSubKey(DOMAINS_KEY, domain);

        string serviceName = segmentList[0];
        RegistryKey trustedSiteKey = currentUserKey.GetOrCreateSubKey(DOMAINS_KEY + @"/" + domain, serviceName);

        SetDomainNameValue(trustedSiteKey);
    }

    static void SetDomainNameValue(RegistryKey subDomainRegistryKey)
    {
        object securityValue = subDomainRegistryKey.GetValue(ALL_PROTOCOL);
        if (securityValue == null || Convert.ToInt32(securityValue) != TRUSTED_SITE_CODE)
        {
            subDomainRegistryKey.SetValue(ALL_PROTOCOL, TRUSTED_SITE_CODE, RegistryValueKind.DWord);
        }
    }
}

static class RegistryKeyExtension
{
    public static RegistryKey GetOrCreateSubKey(this RegistryKey registryKey, string parentString, string subString)
    {
        RegistryKey subKey = registryKey.OpenSubKey(parentString + @"/" + subString, true);
        if (subKey == null)
            subKey = registryKey.CreateSubKey(parentString, subString);

        return subKey;
    }

    public static RegistryKey CreateSubKey(this RegistryKey registryKey, string parentString, string subString)
    {
        RegistryKey parentKey = registryKey.OpenSubKey(parentString, true);
        if (parentKey == null)
            throw new Exception("BUG : parent key " + parentString + " is not exist."); 

        return parentKey.CreateSubKey(subString);
    }
}

Answer 7

Además de agregar el dominio a la lista de Sitios de confianza , es posible que deba cambiar la configuración "Solicitar automáticamente descargas de archivos" para la zona Sitios de confianza. Para hacerlo programáticamente, usted modifica la clave / valor:

HKCU / Software / Microsoft / Windows / CurrentVersion / Configuración de Internet / Zones / 2 @ 2200

Cambia el valor de 3 (Deshabilitar) a 0 (Habilitar). Aquí hay un código de C # para hacer eso:

public void DisableForTrustedSitesZone()
{
    const string ZonesLocation = @"Software/Microsoft/Windows/CurrentVersion/Internet Settings/Zones";
    const int TrustedSiteZone = 2;

    const string AutoPromptForFileDownloadsValueName = @"2200";
    const int AutoPromptForFileDownloadsValueEnable = 0x00;     // Bypass security bar prompt

    using (RegistryKey currentUserKey = Registry.CurrentUser)
    {
        RegistryKey trustedSiteZoneKey = currentUserKey.OpenSubKey(string.Format(@"{0}/{1:d}", ZonesLocation, TrustedSiteZone), true);
        trustedSiteZoneKey.SetValue(AutoPromptForFileDownloadsValueName, AutoPromptForFileDownloadsValueEnable, RegistryValueKind.DWord);
    }
}