설치 그룹 정책

나는 다음과 같은 환경 설정이 웹 응용 프로그램 작업입니다

웹 사이트 크롬에서 작동하도록 설계되었습니다

는 크롬에 따라 달라집니다 Chrome Play 스토어에서 자체 개발 한 익스텐션
Google 시스템 팀은 ExtensionInstallForcelist 그룹 정책 (여기에서 자세한 내용은 http://dev.chromium.org/administrators/policy-list-3#ExtensionInstallForcelist)을 쉽게 설정할 수 있습니다. 이렇게하면 Chrome이 확장 프로그램을 가져와 수동으로 사용자 개입하지 않고 필요에 따라 업데이트 할 수있게합니다.
이것은 이미지 장치에서 모두 설정되므로 별도의 브라우저 및 그룹 정책을 사용하는 별도의 장치로 각각 고유 번호를 가져옵니다.

제가 직면 한 문제는이 그룹 정책으로 Chromedriver 인스턴스를 사용하려고 할 때입니다.

정책을 사용하도록 설정하면 "확장자를 가져 오지 못했습니다. 확장자 ID가 관리자에 의해 차단되었습니다."라는 오류가 표시됩니다. 우리 테스트를 실행할 때.

크롬 옵션 (확장 프로그램 추가)을 통해 Chromedriver에 확장 프로그램을 추가했기 때문에 발생합니다.

이 문제를 해결하기 위해 이미지 장치에서 그룹 정책을 수동으로 끌 수는 있지만 Chromedriver에서 확장 프로그램을 설치할 수 있도록 그룹 정책에 추가 할 수있는 설정이 있는지 궁금합니다. 로 작동하지 않았다 - 그룹 정책 설정 레지스트리 값의

명령 줄 변질이 :

나는이 그렇지 않으면 작동하지 않았다 해결하기 위해 여러 가지 방법을 시도했습니다 레지스트리 값을 변경해도 여전히 테스트를 실행하는 중에 오류가 발생했습니다.
그룹 정책을 변경하는 PowerShell은 그룹 정책 가져 오기 cmdlet을 추가로 설치해야만 작동합니다.
GPMC C# 라이브러리 사용 - 도서관은이 시점에서 시대에 뒤진 것으로 보입니다 (일부는 .NET 2.0 만 사용합니다). 클래스를 사용하기 위해 일부 코드를 설정할 수 있었지만 GPODomain 개체를 만들기위한 "참조 누락"예외가 발생했습니다. 내 솔루션에 대한 참조가 있어도

모든 제안 사항에 대해 미리 감사드립니다. Chromedriver가 강제 설치 그룹 정책으로 작동하도록 만들기.

출처

2017-05-23 Cameron Weaver

웹에서 여러 답변을 여러 번 살펴본 후에이 솔루션이 작동하는 것으로 나타났습니다.

[STAThread] 
    private static bool DisabledChromeExtensionGPO() 
    { 
     var PolicyExists = ComputerGroupPolicyObject.GetPolicySetting(@"HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Google\Chrome\ExtensionInstallForcelist!1"); 

     if (PolicyExists != null) 
     { 

      ComputerGroupPolicyObject.SetPolicySetting(@"HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Google\Chrome\ExtensionInstallForcelist!1", "null", RegistryValueKind.String); 
     } 

     return true; 
    }

동안이 같은 호출로 크롬 확장 그룹 정책을 설치 그런

}

using Microsoft.Win32; 
using Microsoft.Win32.SafeHandles; 
using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Reflection; 
using System.Runtime.InteropServices; 
using System.Text; 
using System.Threading; 
using System.Threading.Tasks; 

namespace Automation.Core 
{ 
[ComImport, Guid("EA502722-A23D-11d1-A7D3-0000F87571E3")] 
internal class GPClass 
{ 
} 

[ComImport, Guid("EA502723-A23D-11d1-A7D3-0000F87571E3"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] 
public interface IGroupPolicyObject 
{ 
    uint New([MarshalAs(UnmanagedType.LPWStr)] string domainName, [MarshalAs(UnmanagedType.LPWStr)] string displayName, uint flags); 

    uint OpenDSGPO([MarshalAs(UnmanagedType.LPWStr)] string path, uint flags); 

    uint OpenLocalMachineGPO(uint flags); 

    uint OpenRemoteMachineGPO([MarshalAs(UnmanagedType.LPWStr)] string computerName, uint flags); 

    uint Save([MarshalAs(UnmanagedType.Bool)] bool machine, [MarshalAs(UnmanagedType.Bool)] bool add, [MarshalAs(UnmanagedType.LPStruct)] Guid extension, [MarshalAs(UnmanagedType.LPStruct)] Guid app); 

    uint Delete(); 

    uint GetName([MarshalAs(UnmanagedType.LPWStr)] StringBuilder name, int maxLength); 

    uint GetDisplayName([MarshalAs(UnmanagedType.LPWStr)] StringBuilder name, int maxLength); 

    uint SetDisplayName([MarshalAs(UnmanagedType.LPWStr)] string name); 

    uint GetPath([MarshalAs(UnmanagedType.LPWStr)] StringBuilder path, int maxPath); 

    uint GetDSPath(uint section, [MarshalAs(UnmanagedType.LPWStr)] StringBuilder path, int maxPath); 

    uint GetFileSysPath(uint section, [MarshalAs(UnmanagedType.LPWStr)] StringBuilder path, int maxPath); 

    uint GetRegistryKey(uint section, out IntPtr key); 

    uint GetOptions(out uint options); 

    uint SetOptions(uint options, uint mask); 

    uint GetType(out IntPtr gpoType); 

    uint GetMachineName([MarshalAs(UnmanagedType.LPWStr)] StringBuilder name, int maxLength); 

    uint GetPropertySheetPages(out IntPtr pages); 
} 


public enum GroupPolicySection 
{ 
    Root = 0, 
    User = 1, 
    Machine = 2, 
} 

public abstract class GroupPolicyObject 
{ 
    protected const int MaxLength = 1024; 

    /// <summary> 
    /// The snap-in that processes .pol files 
    /// </summary> 
    private static readonly Guid RegistryExtension = new Guid(0x35378EAC, 0x683F, 0x11D2, 0xA8, 0x9A, 0x00, 0xC0, 0x4F, 0xBB, 0xCF, 0xA2); 

    /// <summary> 
    /// This application 
    /// </summary> 
    private static readonly Guid LocalGuid = new Guid(GetAssemblyAttribute<GuidAttribute>(Assembly.GetExecutingAssembly()).Value); 

    protected IGroupPolicyObject Instance = (IGroupPolicyObject) new GPClass(); 

    static T GetAssemblyAttribute<T>(ICustomAttributeProvider assembly) where T : Attribute 
    { 
     object[] attributes = assembly.GetCustomAttributes(typeof(T), true); 
     if (attributes.Length == 0) 
      return null; 

     return (T)attributes[0]; 
    } 

    public void Save() 
    { 
     var result = Instance.Save(true, true, RegistryExtension, LocalGuid); 
     if (result != 0) 
     { 
      throw new Exception("Error saving machine settings"); 
     } 

     result = Instance.Save(false, true, RegistryExtension, LocalGuid); 
     if (result != 0) 
     { 
      throw new Exception("Error saving user settings"); 
     } 
    } 

    public RegistryKey GetRootRegistryKey(GroupPolicySection section) 
    { 
     IntPtr key; 
     var result = Instance.GetRegistryKey((uint)section, out key); 
     if (result != 0) 
     { 
      throw new Exception(string.Format("Unable to get section '{0}'", Enum.GetName(typeof(GroupPolicySection), section))); 
     } 

     var handle = new SafeRegistryHandle(key, true); 
     return RegistryKey.FromHandle(handle, RegistryView.Default); 
    } 
} 

public class GroupPolicyObjectSettings 
{ 
    public readonly bool LoadRegistryInformation; 
    public readonly bool Readonly; 

    public GroupPolicyObjectSettings(bool loadRegistryInfo = true, bool readOnly = false) 
    { 
     LoadRegistryInformation = loadRegistryInfo; 
     Readonly = readOnly; 
    } 

    private const uint RegistryFlag = 0x00000001; 
    private const uint ReadonlyFlag = 0x00000002; 

    internal uint Flag 
    { 
     get 
     { 
      uint flag = 0x00000000; 
      if (LoadRegistryInformation) 
      { 
       flag |= RegistryFlag; 
      } 

      if (Readonly) 
      { 
       flag |= ReadonlyFlag; 
      } 

      return flag; 
     } 
    } 
} 

public class ComputerGroupPolicyObject : GroupPolicyObject 
{ 
    public readonly bool IsLocal; 

    public ComputerGroupPolicyObject(GroupPolicyObjectSettings options = null) 
    { 
     options = options ?? new GroupPolicyObjectSettings(); 
     var result = Instance.OpenLocalMachineGPO(options.Flag); 
     if (result != 0) 
     { 
      throw new Exception("Unable to open local machine GPO"); 
     } 
     IsLocal = true; 
    } 

    public static void SetPolicySetting(string registryInformation, string settingValue, RegistryValueKind registryValueKind) 
    { 
     string valueName; 
     GroupPolicySection section; 
     string key = Key(registryInformation, out valueName, out section); 

     // Thread must be STA 
     Exception exception = null; 
     var t = new Thread(() => 
     { 
      try 
      { 
       var gpo = new ComputerGroupPolicyObject(); 
       using (RegistryKey rootRegistryKey = gpo.GetRootRegistryKey(section)) 
       { 
        // Data can't be null so we can use this value to indicate key must be delete 
        if (settingValue == null) 
        { 
         using (RegistryKey subKey = rootRegistryKey.OpenSubKey(key, true)) 
         { 
          if (subKey != null) 
          { 
           subKey.DeleteValue(valueName); 
          } 
         } 
        } 
        else 
        { 
         using (RegistryKey subKey = rootRegistryKey.CreateSubKey(key)) 
         { 
          subKey.SetValue(valueName, settingValue, registryValueKind); 
         } 
        } 
       } 

       gpo.Save(); 
      } 
      catch (Exception ex) 
      { 
       exception = ex; 
      } 
     }); 
     t.SetApartmentState(ApartmentState.STA); 
     t.Start(); 
     t.Join(); 

     if (exception != null) 
      throw exception; 
    } 

    public static object GetPolicySetting(string registryInformation) 
    { 
     string valueName; 
     GroupPolicySection section; 
     string key = Key(registryInformation, out valueName, out section); 

     // Thread must be STA 
     object result = null; 
     var t = new Thread(() => 
     { 
      var gpo = new ComputerGroupPolicyObject(); 
      using (RegistryKey rootRegistryKey = gpo.GetRootRegistryKey(section)) 
      { 
       // Data can't be null so we can use this value to indicate key must be delete 
       using (RegistryKey subKey = rootRegistryKey.OpenSubKey(key, true)) 
       { 
        if (subKey == null) 
        { 
         result = null; 
        } 
        else 
        { 
         result = subKey.GetValue(valueName); 
        } 
       } 
      } 
     }); 
     t.SetApartmentState(ApartmentState.STA); 
     t.Start(); 
     t.Join(); 

     return result; 
    } 

    public static string Key(string registryInformation, out string value, out GroupPolicySection section) 
    { 
     // Parse parameter of format HKCU\Software\Policies\Microsoft\Windows\Personalization!NoChangingSoundScheme 
     string[] split = registryInformation.Split('!'); 
     string key = split[0]; 
     string hive = key.Substring(0, key.IndexOf('\\')); 
     key = key.Substring(key.IndexOf('\\') + 1); 

     value = split[1]; 

     if (hive.Equals(@"HKLM", StringComparison.OrdinalIgnoreCase) 
      || hive.Equals(@"HKEY_LOCAL_MACHINE", StringComparison.OrdinalIgnoreCase)) 
     { 
      section = GroupPolicySection.Machine; 
     } 
     else 
     { 
      section = GroupPolicySection.User; 
     } 
     return key; 
    } 
}

를 강제로 전원을 끄십시오

그것과 상호 작용을 처리하기 위해 그룹 정책 클래스 만들기 정책에는 여전히 regedit에 나열된 키가 있습니다. 키 값은 null로 설정됩니다.

값을 null로 설정하면 Chrome 드라이버가이 시점에서 문제없이 로컬 Chrome 확장 파일을로드 할 수있었습니다.

출처

2017-10-26 17:54:11

설치 그룹 정책

답변

관련 문제