public static StrongNameMembershipCondition FullTrustMembership(string name, Key key) { StrongNamePublicKeyBlob snkb = null; switch (key) { case Key.Ecma: if (_ecma == null) { _ecma = new StrongNamePublicKeyBlob(_ecmaKey); } snkb = _ecma; break; case Key.MsFinal: if (_msFinal == null) { _msFinal = new StrongNamePublicKeyBlob(_msFinalKey); } snkb = _msFinal; break; } if (_fxVersion == null) { _fxVersion = new Version(Consts.FxVersion); } return(new StrongNameMembershipCondition(snkb, name, _fxVersion)); }
public void FixtureSetUp() { wrongEvidence = new Site("test"); allEmpty = new Evidence(); AssemblyName an = typeof(int).Assembly.GetName(); name = an.Name; version = an.Version; blob = new StrongNamePublicKeyBlob(an.GetPublicKey()); ms = new StrongNamePublicKeyBlob(_msFinalKey); hostEcmaCorlibVersion = CreateHostEvidence(new StrongName(blob, name, version)); hostEcmaVersion = CreateHostEvidence(new StrongName(blob, " ", version)); hostMsSystemSecurityVersion = CreateHostEvidence(new StrongName(ms, "System.Security", version)); hostMsVersion = CreateHostEvidence(new StrongName(ms, " ", version)); hostOther = CreateHostEvidence(wrongEvidence); assemblyEcmaCorlibVersion = CreateAssemblyEvidence(new StrongName(blob, name, version)); assemblyEcmaVersion = CreateAssemblyEvidence(new StrongName(blob, " ", version)); assemblyMsSystemSecurityVersion = CreateAssemblyEvidence(new StrongName(ms, "System.Security", version)); assemblyMsVersion = CreateAssemblyEvidence(new StrongName(ms, " ", version)); assemblyOther = CreateAssemblyEvidence(wrongEvidence); }
/// <summary> /// Gets the name of the strong. /// </summary> /// <param name="assembly">The assembly.</param> /// <returns></returns> public static System.Security.Policy.StrongName GetStrongName(Assembly assembly) { if (assembly == null) { throw new ArgumentNullException("assembly"); } AssemblyName assemblyName = assembly.GetName(); // get the public key blob byte[] publicKey = assemblyName.GetPublicKey(); if (publicKey == null || publicKey.Length == 0) { throw new InvalidOperationException( String.Format("{0} is not strongly named", assembly)); } StrongNamePublicKeyBlob keyBlob = new StrongNamePublicKeyBlob(publicKey); // create the StrongName return(new System.Security.Policy.StrongName( keyBlob, assemblyName.Name, assemblyName.Version)); }
public static void StrongNamePublicKeyBlobTests() { StrongNamePublicKeyBlob snpkb = new StrongNamePublicKeyBlob(new byte[1]); bool testbool = snpkb.Equals(new object()); int hash = snpkb.GetHashCode(); string teststring = snpkb.ToString(); }
public void Intersect() { StrongNamePublicKeyBlob blob = new StrongNamePublicKeyBlob(ecma); StrongNameIdentityPermission snip = new StrongNameIdentityPermission(blob, "mono", new Version(1, 2, 3, 4)); StrongNameIdentityPermission intersect = (StrongNameIdentityPermission)snip.Intersect(null); Assert.IsNull(intersect, "snip N null"); StrongNameIdentityPermission empty = new StrongNameIdentityPermission(PermissionState.None); intersect = (StrongNameIdentityPermission)snip.Intersect(empty); #if NET_2_0 Assert.IsNull(intersect, "snip N empty"); #else Compare(empty, intersect, "snip U empty"); #endif intersect = (StrongNameIdentityPermission)snip.Intersect(snip); Compare(snip, intersect, "snip U snip"); StrongNameIdentityPermission samePk = new StrongNameIdentityPermission(blob, "novell", new Version(1, 2)); intersect = (StrongNameIdentityPermission)snip.Intersect(samePk); Assert.IsNull(intersect, "(snip N samePk)"); // strange, I would have expected a SNIP with the same public key... }
public void InvalidPublicKey() { StrongNamePublicKeyBlob snpkb = new StrongNamePublicKeyBlob(bad); // Proof that there's no validation on public key Assert.AreEqual("0BAD", snpkb.ToString(), "ToString(BAD)"); }
public void PublicKey_Null() { StrongNamePublicKeyBlob blob = new StrongNamePublicKeyBlob(ecma); StrongNameIdentityPermission snip = new StrongNameIdentityPermission(blob, "mono", new Version(1, 2, 3, 4)); snip.PublicKey = null; }
public void PublicKey() { StrongNamePublicKeyBlob snpkb = new StrongNamePublicKeyBlob(pk); Assert.IsTrue(snpkb.Equals(snpkb), "Equals(Self)"); Assert.IsFalse(snpkb.Equals(null), "Equals(null)"); Assert.AreEqual("00240000048000009400000006020000002400005253413100040000010001003DBD7208C62B0EA8C1C058072B635F7C9ABDCB22DB20B2A9DADAEFE800642F5D8DEB7802F7A5367728D7558D1468DBEB2409D02B131B926E2E59544AAC18CFC909023F4FA83E94001FC2F11A27477D1084F514B861621A0C66ABD24C4B9FC90F3CD8920FF5FFCED76E5C6FB1F57DD356F96727A4A5485B079344004AF8FFA4CB", snpkb.ToString(), "ToString(pk)"); StrongNamePublicKeyBlob snpkb2 = new StrongNamePublicKeyBlob(pk); Assert.IsTrue(snpkb.Equals(snpkb2), "Equals()-true"); StrongNamePublicKeyBlob snpkb3 = new StrongNamePublicKeyBlob(bad); Assert.IsFalse(snpkb.Equals(snpkb3), "Equals()-false"); // non standard get hash code - why ??? Assert.AreEqual(snpkb2.GetHashCode(), snpkb.GetHashCode(), "GetHashCode-0"); #if NET_2_0 // the first 4 bytes has code has been fixed in 2.0 beta 1 #elif NET_1_1 // It seems to be the first four bytes of the public key data // which seems like non sense as all valid public key will have the same header ? Assert.AreEqual(2359296, snpkb.GetHashCode(), "GetHashCode-1"); Assert.AreEqual(2359296, snpkb2.GetHashCode(), "GetHashCode-2"); Assert.AreEqual(2989, snpkb3.GetHashCode(), "GetHashCode-3"); byte[] header = { 0x00, 0x24, 0x00, 0x00 }; StrongNamePublicKeyBlob snpkb4 = new StrongNamePublicKeyBlob(header); Assert.AreEqual(2359296, snpkb4.GetHashCode(), "GetHashCode-4"); #endif }
internal void FromXml(SecurityElement element) { if (element == null) { throw new ArgumentNullException("element"); } if (string.Compare(element.Tag, "StrongName", StringComparison.Ordinal) != 0) { throw new ArgumentException(Environment.GetResourceString("Argument_InvalidXML")); } this.m_publicKeyBlob = null; this.m_version = null; string hexString = element.Attribute("Key"); if (hexString != null) { this.m_publicKeyBlob = new StrongNamePublicKeyBlob(Hex.DecodeHexString(hexString)); } this.m_name = element.Attribute("Name"); string version = element.Attribute("Version"); if (version != null) { this.m_version = new System.Version(version); } }
internal void FromXml(SecurityElement element) { if (element == null) { throw new ArgumentNullException("element"); } if (String.Compare(element.Tag, "StrongName", StringComparison.Ordinal) != 0) { throw new ArgumentException(Environment.GetResourceString("Argument_InvalidXML")); } Contract.EndContractBlock(); m_publicKeyBlob = null; m_version = null; string key = element.Attribute("Key"); if (key != null) { m_publicKeyBlob = new StrongNamePublicKeyBlob(System.Security.Util.Hex.DecodeHexString(key)); } m_name = element.Attribute("Name"); string version = element.Attribute("Version"); if (version != null) { m_version = new Version(version); } }
// Implement the ISecurityPolicyEncodable interface. public void FromXml(SecurityElement et, PolicyLevel level) { if (et == null) { throw new ArgumentNullException("et"); } if (et.Tag != "IMembershipCondition") { throw new ArgumentException(_("Security_PolicyName")); } if (et.Attribute("version") != "1") { throw new ArgumentException(_("Security_PolicyVersion")); } String value = et.Attribute("PublicKey"); if (value != null) { blob = new StrongNamePublicKeyBlob(value); } else { throw new ArgumentException(_("Arg_PublicKeyBlob")); } name = et.Attribute("Name"); value = et.Attribute("AssemblyVersion"); if (value != null) { version = new Version(value); } else { version = null; } }
internal StrongName(StrongNamePublicKeyBlob blob, string name, System.Version version, Assembly assembly) { if (name == null) { throw new ArgumentNullException("name"); } if (string.IsNullOrEmpty(name)) { throw new ArgumentException(Environment.GetResourceString("Argument_EmptyStrongName")); } if (blob == null) { throw new ArgumentNullException("blob"); } if (version == null) { throw new ArgumentNullException("version"); } RuntimeAssembly assembly2 = assembly as RuntimeAssembly; if ((assembly != null) && (assembly2 == null)) { throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeAssembly"), "assembly"); } this.m_publicKeyBlob = blob; this.m_name = name; this.m_version = version; this.m_assembly = assembly2; }
/// <internalonly/> int IBuiltInEvidence.InitFromBuffer(char[] buffer, int position) { int length = BuiltInEvidenceHelper.GetIntFromCharArray(buffer, position); position += 2; m_publicKeyBlob = new StrongNamePublicKeyBlob(); m_publicKeyBlob.PublicKey = new byte[length]; int lengthInChars = ((length - 1) / 2) + 1; Buffer.InternalBlockCopy(buffer, position * 2, m_publicKeyBlob.PublicKey, 0, length); position += lengthInChars; int major = BuiltInEvidenceHelper.GetIntFromCharArray(buffer, position); int minor = BuiltInEvidenceHelper.GetIntFromCharArray(buffer, position + 2); int build = BuiltInEvidenceHelper.GetIntFromCharArray(buffer, position + 4); int revision = BuiltInEvidenceHelper.GetIntFromCharArray(buffer, position + 6); m_version = new Version(major, minor, build, revision); position += 8; length = BuiltInEvidenceHelper.GetIntFromCharArray(buffer, position); position += 2; m_name = new String(buffer, position, length); return(position + length); }
public static StrongNameMembershipCondition FullTrustMembership(string name, DefaultPolicies.Key key) { StrongNamePublicKeyBlob blob = null; if (key != DefaultPolicies.Key.Ecma) { if (key == DefaultPolicies.Key.MsFinal) { if (DefaultPolicies._msFinal == null) { DefaultPolicies._msFinal = new StrongNamePublicKeyBlob(DefaultPolicies._msFinalKey); } blob = DefaultPolicies._msFinal; } } else { if (DefaultPolicies._ecma == null) { DefaultPolicies._ecma = new StrongNamePublicKeyBlob(DefaultPolicies._ecmaKey); } blob = DefaultPolicies._ecma; } if (DefaultPolicies._fxVersion == null) { DefaultPolicies._fxVersion = new Version("2.0.0.0"); } return(new StrongNameMembershipCondition(blob, name, DefaultPolicies._fxVersion)); }
internal static StrongName CreateStrongName(Assembly assembly) { System.Diagnostics.Contracts.Contract.Requires(assembly != null); // Since there is no managed API for finding the GAC path, I // assert path discovery for all local files. FileIOPermission permission = new FileIOPermission(PermissionState.None); permission.AllLocalFiles = FileIOPermissionAccess.PathDiscovery; permission.Assert(); AssemblyName assemblyName = assembly.GetName(); CodeAccessPermission.RevertAssert(); // get the public key blob byte[] publicKey = assemblyName.GetPublicKey(); if (publicKey == null || publicKey.Length == 0) { throw new InvalidOperationException(Res.NoStrongName); } StrongNamePublicKeyBlob keyBlob = new StrongNamePublicKeyBlob(publicKey); // and create the StrongName return(new StrongName(keyBlob, assemblyName.Name, assemblyName.Version)); }
public StrongName(StrongNamePublicKeyBlob blob, String name, Version version) { if (name == null) { throw new ArgumentNullException("name"); } if (name.Equals("")) { throw new ArgumentException(Environment.GetResourceString("Argument_EmptyStrongName")); } if (blob == null) { throw new ArgumentNullException("blob"); } if (version == null) { throw new ArgumentNullException("version"); } m_publicKeyBlob = blob; m_name = name; m_version = version; }
public void Name_Empty() { StrongNamePublicKeyBlob blob = new StrongNamePublicKeyBlob(ecma); StrongNameIdentityPermission snip = new StrongNameIdentityPermission(blob, "mono", new Version(1, 2, 3, 4)); snip.Name = String.Empty; }
internal StrongName(StrongNamePublicKeyBlob blob, String name, Version version, Assembly assembly) { if (name == null) { throw new ArgumentNullException("name"); } if (String.IsNullOrEmpty(name)) { throw new ArgumentException(Environment.GetResourceString("Argument_EmptyStrongName")); } if (blob == null) { throw new ArgumentNullException("blob"); } if (version == null) { throw new ArgumentNullException("version"); } Contract.EndContractBlock(); RuntimeAssembly rtAssembly = assembly as RuntimeAssembly; if (assembly != null && rtAssembly == null) { throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeAssembly"), "assembly"); } m_publicKeyBlob = blob; m_name = name; m_version = version; m_assembly = rtAssembly; }
public void Union() { StrongNamePublicKeyBlob blob = new StrongNamePublicKeyBlob(ecma); StrongNameIdentityPermission snip = new StrongNameIdentityPermission(blob, "mono", new Version(1, 2, 3, 4)); StrongNameIdentityPermission union = (StrongNameIdentityPermission)snip.Union(null); Compare(snip, union, "snip U null"); StrongNameIdentityPermission empty = new StrongNameIdentityPermission(PermissionState.None); union = (StrongNameIdentityPermission)snip.Union(empty); Compare(snip, union, "snip U empty"); union = (StrongNameIdentityPermission)snip.Union(snip); Compare(snip, union, "snip U snip"); // note: can't be tested with PermissionState.Unrestricted StrongNameIdentityPermission samePk = new StrongNameIdentityPermission(blob, null, null); union = (StrongNameIdentityPermission)snip.Union(samePk); #if !NET_2_0 // can't compare the properties with multiple entries Compare(snip, union, "snip U samePk"); #endif Assert.IsTrue(snip.IsSubsetOf(union), "snip.IsSubsetOf (union)"); union = (StrongNameIdentityPermission)samePk.Union(snip); #if !NET_2_0 // can't compare the properties with multiple entries Compare(snip, union, "samePk U snip"); #endif Assert.IsTrue(samePk.IsSubsetOf(union), "snip.IsSubsetOf (union)"); }
static internal Evidence GetDefaultHostEvidence(Assembly a) { Evidence e = new Evidence(); string aname = a.EscapedCodeBase; // by default all assembly have the Zone, Url and Hash evidences e.AddHost(Zone.CreateFromUrl(aname)); e.AddHost(new Url(aname)); e.AddHost(new Hash(a)); // non local files (e.g. http://) also get a Site evidence if (String.Compare("FILE://", 0, aname, 0, 7, true, CultureInfo.InvariantCulture) != 0) { e.AddHost(Site.CreateFromUrl(aname)); } // strongnamed assemblies gets a StrongName evidence AssemblyName an = a.GetName(); byte[] pk = an.GetPublicKey(); if ((pk != null) && (pk.Length > 0)) { StrongNamePublicKeyBlob blob = new StrongNamePublicKeyBlob(pk); e.AddHost(new StrongName(blob, an.Name, an.Version)); } // Authenticode(r) signed assemblies get a Publisher evidence if (IsAuthenticodePresent(a)) { try { X509Certificate x509 = X509Certificate.CreateFromSignedFile(a.Location); e.AddHost(new Publisher(x509)); } catch (CryptographicException) { } } // assemblies loaded from the GAC also get a Gac evidence (new in Fx 2.0) if (a.GlobalAssemblyCache) { e.AddHost(new GacInstalled()); } // the current HostSecurityManager may add/remove some evidence AppDomainManager dommgr = AppDomain.CurrentDomain.DomainManager; if (dommgr != null) { if ((dommgr.HostSecurityManager.Flags & HostSecurityManagerOptions.HostAssemblyEvidence) == HostSecurityManagerOptions.HostAssemblyEvidence) { e = dommgr.HostSecurityManager.ProvideAssemblyEvidence(a, e); } } return(e); }
public static StrongName StrongnameFromType(Type type) { Assembly assembly = type.Assembly; string name = type.Name; Version version = assembly.GetName().Version; StrongNamePublicKeyBlob strongName = new StrongNamePublicKeyBlob(assembly.GetName().GetPublicKey()); return(new StrongName(strongName, name, version)); }
private StrongNameIdentityPermission GetUnion() { StrongNamePublicKeyBlob blob = new StrongNamePublicKeyBlob(ecma); StrongNameIdentityPermission snip = new StrongNameIdentityPermission(blob, "mono", new Version(1, 2, 3, 4)); StrongNamePublicKeyBlob blob2 = new StrongNamePublicKeyBlob(new byte[16]); StrongNameIdentityPermission diffPk = new StrongNameIdentityPermission(blob2, "mono", new Version(1, 2, 3, 4)); return((StrongNameIdentityPermission)snip.Union(diffPk)); }
/// <summary> /// Get the StrongName of the given assembly. /// </summary> /// <param name="ass"></param> /// <returns></returns> public static StrongName FromAssembly(Assembly ass) { var name = ass.GetName(); byte[] pk = name.GetPublicKey(); var blob = new StrongNamePublicKeyBlob(pk); return(new StrongName(blob, name.Name, name.Version)); }
public void StrongName_GetRequiredSize() { byte[] pk = { 0x00, 0x24, 0x00, 0x00, 0x04, 0x80, 0x00, 0x00, 0x94, 0x00, 0x00, 0x00, 0x06, 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x52, 0x53, 0x41, 0x31, 0x00, 0x04, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x3D, 0xBD, 0x72, 0x08, 0xC6, 0x2B, 0x0E, 0xA8, 0xC1, 0xC0, 0x58, 0x07, 0x2B, 0x63, 0x5F, 0x7C, 0x9A, 0xBD, 0xCB, 0x22, 0xDB, 0x20, 0xB2, 0xA9, 0xDA, 0xDA, 0xEF, 0xE8, 0x00, 0x64, 0x2F, 0x5D, 0x8D, 0xEB, 0x78, 0x02, 0xF7, 0xA5, 0x36, 0x77, 0x28, 0xD7, 0x55, 0x8D, 0x14, 0x68, 0xDB, 0xEB, 0x24, 0x09, 0xD0, 0x2B, 0x13, 0x1B, 0x92, 0x6E, 0x2E, 0x59, 0x54, 0x4A, 0xAC, 0x18, 0xCF, 0xC9, 0x09, 0x02, 0x3F, 0x4F, 0xA8, 0x3E, 0x94, 0x00, 0x1F, 0xC2, 0xF1, 0x1A, 0x27, 0x47, 0x7D, 0x10, 0x84, 0xF5, 0x14, 0xB8, 0x61, 0x62, 0x1A, 0x0C, 0x66, 0xAB, 0xD2, 0x4C, 0x4B, 0x9F, 0xC9, 0x0F, 0x3C, 0xD8, 0x92, 0x0F, 0xF5, 0xFF, 0xCE, 0xD7, 0x6E, 0x5C, 0x6F, 0xB1, 0xF5, 0x7D, 0xD3, 0x56, 0xF9, 0x67, 0x27, 0xA4, 0xA5, 0x48, 0x5B, 0x07, 0x93, 0x44, 0x00, 0x4A, 0xF8, 0xFF, 0xA4, 0xCB }; StrongNamePublicKeyBlob snpkb = new StrongNamePublicKeyBlob(pk); StrongName sn = new StrongName(snpkb, "mono", new Version()); Assert.AreEqual(97, GetRequiredSize(sn, true), "GetRequiredSize-true"); Assert.AreEqual(93, GetRequiredSize(sn, false), "GetRequiredSize-false"); }
private StrongName GetStrongName(Type type) { AssemblyName aname = type.Assembly.GetName(); byte[] pubkey = aname.GetPublicKey(); var blob = new StrongNamePublicKeyBlob(pubkey); return(new StrongName(blob, aname.Name, aname.Version)); }
public override String ToString() { StringBuilder builder = new StringBuilder(); builder.Append("Hash - "); builder.Append(hashAlg.GetType().AssemblyQualifiedName); builder.Append(" = "); builder.Append(StrongNamePublicKeyBlob.ToHex(value)); return(builder.ToString()); }
public void Name_Empty() { StrongNamePublicKeyBlob blob = new StrongNamePublicKeyBlob(ecma); StrongNameIdentityPermission snip = new StrongNameIdentityPermission(blob, "mono", new Version(1, 2, 3, 4)); snip.Name = String.Empty; #if !NET_2_0 Assert.AreEqual(String.Empty, snip.Name, "Name"); #endif }
public void Version() { StrongNamePublicKeyBlob blob = new StrongNamePublicKeyBlob(ecma); StrongNameIdentityPermission snip = new StrongNameIdentityPermission(blob, "mono", new Version(1, 2, 3, 4)); Assert.AreEqual("1.2.3.4", snip.Version.ToString(), "Version-1"); snip.Version = null; Assert.IsNull(snip.Version, "Version-2"); snip.Version = new Version(1, 2, 3); Assert.AreEqual("1.2.3", snip.Version.ToString(), "Version-3"); }
public void IsSubsetOf() { StrongNamePublicKeyBlob blob = new StrongNamePublicKeyBlob(ecma); StrongNameIdentityPermission snip = new StrongNameIdentityPermission(blob, "mono", new Version(1, 2, 3, 4)); Assert.IsFalse(snip.IsSubsetOf(null), "snip.IsSubsetOf (null)"); StrongNameIdentityPermission empty = new StrongNameIdentityPermission(PermissionState.None); Assert.IsTrue(empty.IsSubsetOf(null), "empty.IsSubsetOf (null)"); }
public StrongNameMembershipCondition (StrongNamePublicKeyBlob blob, String name, Version version) { if (blob == null) { throw new ArgumentNullException("blob"); } this.blob = blob; this.name = name; this.version = version; }
public StrongNameIdentityPermission(StrongNamePublicKeyBlob blob, string name, Version version) { }
// Create new code groups using the custom named permission sets previously created. private static void CreateCodeGroups() { // Create instances of the named permission sets created earlier to establish the // permissions for the new code groups. NamedPermissionSet companyCodeSet = new NamedPermissionSet("MyCompany",PermissionState.Unrestricted); NamedPermissionSet departmentCodeSet = new NamedPermissionSet("MyDepartment",PermissionState.Unrestricted); // Create new code groups using the named permission sets. PolicyStatement policyMyCompany = new PolicyStatement(companyCodeSet,PolicyStatementAttribute.LevelFinal); PolicyStatement policyMyDepartment = new PolicyStatement(departmentCodeSet,PolicyStatementAttribute.Exclusive); // Create new code groups using UnionCodeGroup. CodeGroup myCompanyZone = new UnionCodeGroup(new ZoneMembershipCondition(SecurityZone.Intranet), policyMyCompany); myCompanyZone.Name = "MyCompanyCodeGroup"; byte[] b1 = { 0, 36, 0, 0, 4, 128, 0, 0, 148, 0, 0, 0, 6, 2, 0, 0, 0, 36, 0, 0, 82, 83, 65, 49, 0, 4, 0, 0, 1, 0, 1, 0, 237, 146, 145, 51, 34, 97, 123, 196, 90, 174, 41, 170, 173, 221, 41, 193, 175, 39, 7, 151, 178, 0, 230, 152, 218, 8, 206, 206, 170,84, 111, 145, 26, 208, 158, 240, 246, 219, 228, 34, 31, 163, 11, 130, 16, 199, 111, 224, 4, 112, 46, 84, 0, 104, 229, 38, 39, 63, 53, 189, 0, 157, 32, 38, 34, 109, 0, 171, 114, 244, 34, 59, 9, 232, 150, 192, 247, 175, 104, 143, 171, 42, 219, 66, 66, 194, 191, 218, 121, 59, 92, 42, 37, 158, 13, 108, 210, 189, 9, 203, 204, 32, 48, 91, 212, 101, 193, 19, 227, 107, 25, 133, 70, 2, 220, 83, 206, 71, 102, 245, 104, 252, 87, 109, 190, 56, 34, 180}; StrongNamePublicKeyBlob blob = new StrongNamePublicKeyBlob(b1); CodeGroup myDepartmentZone = new UnionCodeGroup(new StrongNameMembershipCondition(blob, null, null), policyMyDepartment); myDepartmentZone.Name = "MyDepartmentCodeGroup"; // Move through the policy levels looking for the Machine policy level. // Create two new code groups at that level. IEnumerator policyEnumerator = SecurityManager.PolicyHierarchy(); while(policyEnumerator.MoveNext()) { // At the Machine level delete already existing copies of the custom code groups, // then create the new code groups. PolicyLevel currentLevel = (PolicyLevel)policyEnumerator.Current; if (currentLevel.Label == "Machine") { // Remove old instances of the custom groups. DeleteCustomCodeGroups(); // Add the new code groups. //******************************************************* // To add a child code group, add the child to the parent prior to adding // the parent to the root. myCompanyZone.AddChild(myDepartmentZone); // Add the parent to the root code group. currentLevel.RootCodeGroup.AddChild(myCompanyZone); SecurityManager.SavePolicy(); } } // Save the security policy. SecurityManager.SavePolicy(); Console.WriteLine("Security policy modified."); Console.WriteLine("New code groups added at the Machine policy level."); }