2009-06-09 12 views
10

Je fais un projet d'automatisation IE en utilisant WatiN.Ajouter par programme des sites de confiance à Internet Explorer

Lorsqu'un fichier à télécharger est cliqué, je reçois le texte suivant dans la barre d'informations Internet Explorer:

Pour protéger votre sécurité, Internet Explorer a bloqué ce site de vous le téléchargement de fichiers à ordinateur.

Pour télécharger le rapport, je peux ajouter manuellement le site à la liste d'Internet Explorer des sites de confiance, mais je préférerais vérifier par programme dans .NET pour voir si le site est digne de confiance et l'ajouter à la liste si ce n'est pas le cas.

FYI, j'utilise actuellement IE7.

+0

Je ne pense pas que vous pouvez ... Mais si vous j'aimerais voir comment! – marcgg

+0

Je ne pense pas que vous pouvez non plus, pour des raisons de sécurité. Cela dit, ils doivent être stockés * quelque part *. Connaissant Microsoft, dans le registre ... – Powerlord

+4

@R. Bemrose, il n'y a aucune raison de sécurité de ne pas le permettre. Si un programme malveillant a un accès en écriture à HKCU, ce n'est pas le pire qu'il pourrait faire. Si un * site * pouvait s'ajouter aux sites de confiance, ce serait mauvais. –

Répondre

12

Jetez un oeil à this

Fondamentalement, il semble que tout ce que vous avez à faire est de créer la clé de Registre dans

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

alors une valeur REG_DWORD nommée « http » avec la valeur == 2

+3

Je suggère d'utiliser TrustedZoneType enum privé { Intranet = 1, TrustedSites = 2, Internet = 3, RestrictedSites = 4 } – itsho

9

Voici l'implémentation que j'ai imaginée pour écrire les clés de registre dans .NET.

Merci de m'avoir placé dans la bonne direction, 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; 
     } 
    } 
} 
+1

Je soumettais un RFC et un patch préliminaire à Watin pour faire de cette partie de la fonctionnalité de WatiN.Core –

+0

Sucré. Existe-t-il un endroit qui décrit comment la communauté peut soumettre des correctifs pour WatiN? –

+0

J'ai simplement posté sur [email protected] un correctif fonctionnel, mais pas de qualité, basé principalement sur le code que vous avez posté ici et j'attendrai s'il y a un intérêt à l'inclure. Je vais poster ici si elle entre. Http://sourceforge.net/mailarchive/forum.php?thread_name=4A2FD162.1020103%40gmx.net&forum_name=watin-development –

5

Je suis content d'avoir trouvé vos commentaires. La seule chose que je peux ajouter aux excellentes contributions est déjà qu'une clé de registre différente est utilisée chaque fois que l'URI contient une adresse IP, c'est-à-dire que l'adresse n'est pas un nom de domaine complet.

Dans ce cas, vous devez utiliser une autre approche:

Imaginez que je souhaite ajouter une adresse IP aux sites de confiance: dire 10.0.1.13 et je me fous de ce protocole.

Sous HKEY_CURRENT_USER \ Software \ Microsoft \ Windows \ CurrentVersion \ Paramètres Internet \ ZoneMap \ Plages, je crée une clé par ex. "Range1" et l'intérieur qui crée les valeurs suivantes:

Un DWORD avec le nom "*" et la valeur 0x2 (pour tous les protocoles (*) et le site de confiance (2)) Une chaîne avec le nom ": Range" avec valeur « 10.0.1.13 »

+0

J'ai utilisé l'approche par clé de domaine avec succès avec une adresse IP. J'ai d'abord essayé l'approche par clé de gamme et cela n'a pas fonctionné. Être précis sur les protocoles semble également important. –

-1

Si un site Web pourrait s'ajouter aux sites de confiance, maintenant ce serait mauvais.

Je ne pas tout à fait aussi longtemps que accords le navigateur demande à l'utilisateur la permission, la capacité d'un site à s'ajouter à des sites de confiance peut simplifier considérablement l'expérience utilisateur, où l'utilisateur fait confiance au domaine et veut l'affichage correct de la page.

L'alternative est que l'utilisateur doive entrer manuellement dans les options internet pour ajouter le domaine, ce qui, pour mes utilisateurs, n'est pas viable.

je suis à la recherche d'un php ou javascript méthode pour le site lui-même à ajouter, soit par une api IE, ou dans le registre que vous avez si obligeamment expliqué ci-dessus!

ont trouvé ces solutions possibles à ce jour:

  • php via shell
  • autres je ne suis pas autorisé à la liste ici parce que je n'ai pas assez de points
2

En plus de adding the domain to the Trusted Sites list, Vous devrez peut-être également modifier le paramètre "Demander automatiquement le téléchargement de fichiers" pour la zone Sites de confiance. Pour ce faire programatically, vous modifiez la clé/valeur:

HKCU \ Software \ Microsoft \ Windows \ CurrentVersion \ Internet Settings \ Zones \ 2 @ 2200

Modifiez la valeur de (Désactiver) à (Activer). Voici un code C# pour le faire:

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); 
    } 
} 
2

Voici la mise en œuvre de l'ajout de sites de confiance à IE programme - basé sur le code même de Mien. Il prend également en charge le nom de domaine et l'adresse IP. La limitation est aucun protocole spécifique pourrait être défini, à la place il utilise simplement "*" pour tous les protocoles.

// 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); 
    } 
} 
1

L'utilisation de powershell est assez facile.

#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 
Questions connexes