public Clerk(string compensator, string description, CompensatorOptions flags) { SecurityPermission permission = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode); permission.Demand(); permission.Assert(); this.Init(compensator, description, flags); }
public void RunApp(string FileName, string arg) { SecurityPermission SP = new SecurityPermission(SecurityPermissionFlag.AllFlags); SP.Assert(); //ProcessStartInfo process = new ProcessStartInfo("cmd", "/c " + FileName )); System.Diagnostics.Process process = new System.Diagnostics.Process(); process.StartInfo.WindowStyle = ProcessWindowStyle.Normal; //process.StartInfo.UseShellExecute = false; //process.StartInfo.RedirectStandardOutput = true; //process.StartInfo.RedirectStandardError = true; //process.StartInfo.CreateNoWindow = true; process.StartInfo.FileName = FileName; process.StartInfo.Arguments = arg; process.StartInfo.WorkingDirectory = System.IO.Path.GetDirectoryName(FileName); //Vista or higher check if (System.Environment.OSVersion.Version.Major >= 6) process.StartInfo.Verb = "runas"; try { process.Start(); process.WaitForExit(); process.Close(); } catch (InvalidOperationException) { //e.ExceptionObject.ToString(); } }
public static void SetAppDomainData() { SecurityPermission sp = new SecurityPermission(SecurityPermissionFlag.ControlAppDomain); sp.Assert(); AppDomain.CurrentDomain.SetData("SQLServerCompactEditionUnderWebHosting", true); }
public ClerkMonitor() { SecurityPermission permission = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode); permission.Demand(); permission.Assert(); this._monitor = new CrmMonitor(); this._version = 0; }
public Clerk(Type compensator, string description, CompensatorOptions flags) { SecurityPermission permission = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode); permission.Demand(); permission.Assert(); this.ValidateCompensator(compensator); string str = "{" + Marshal.GenerateGuidForType(compensator) + "}"; this.Init(str, description, flags); }
/// <summary> /// /// </summary> /// <param name="stream"></param> /// <param name="evidence"></param> /// <returns></returns> public static Assembly ReadAssembly(Stream stream, Evidence evidence) { SecurityPermission securityPermission = new SecurityPermission(SecurityPermissionFlag.ControlEvidence); securityPermission.Assert(); int num = (int)stream.Length; byte[] array = new byte[num]; stream.Read(array, 0, num); try { return Assembly.Load(array, null, evidence); } finally { CodeAccessPermission.RevertAssert(); } }
internal static Win32Exception CreateSafeWin32Exception(int error) { Win32Exception newException = null; // Need to assert SecurtiyPermission, otherwise Win32Exception // will not be able to get the error message. At this point the right // permissions have already been demanded. SecurityPermission securityPermission = new SecurityPermission(PermissionState.Unrestricted); securityPermission.Assert(); try { if (error == 0) newException = new Win32Exception(); else newException = new Win32Exception(error); } finally { SecurityPermission.RevertAssert(); } return newException; }
private CompilerResults FromFileBatch(CompilerParameters options, string[] fileNames) { if( options == null) { throw new ArgumentNullException("options"); } if (fileNames == null) throw new ArgumentNullException("fileNames"); new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Demand(); string outputFile = null; int retValue = 0; CompilerResults results = new CompilerResults(options.TempFiles); SecurityPermission perm1 = new SecurityPermission(SecurityPermissionFlag.ControlEvidence); perm1.Assert(); try { #pragma warning disable 618 results.Evidence = options.Evidence; #pragma warning restore 618 } finally { SecurityPermission.RevertAssert(); } bool createdEmptyAssembly = false; if (options.OutputAssembly == null || options.OutputAssembly.Length == 0) { string extension = (options.GenerateExecutable) ? "exe" : "dll"; options.OutputAssembly = results.TempFiles.AddExtension(extension, !options.GenerateInMemory); // Create an empty assembly. This is so that the file will have permissions that // we can later access with our current credential. If we don't do this, the compiler // could end up creating an assembly that we cannot open. new FileStream(options.OutputAssembly, FileMode.Create, FileAccess.ReadWrite).Close(); createdEmptyAssembly = true; } #if FEATURE_PAL string pdbname = "ildb"; #else string pdbname = "pdb"; #endif // Don't delete pdbs when debug=false but they have specified pdbonly. if (options.CompilerOptions!= null && -1 != CultureInfo.InvariantCulture.CompareInfo.IndexOf(options.CompilerOptions,"/debug:pdbonly", CompareOptions.IgnoreCase)) results.TempFiles.AddExtension(pdbname, true); else results.TempFiles.AddExtension(pdbname); string args = CmdArgsFromParameters(options) + " " + JoinStringArray(fileNames, " "); // Use a response file if the compiler supports it string responseFileArgs = GetResponseFileCmdArgs(options, args); string trueArgs = null; if (responseFileArgs != null) { trueArgs = args; args = responseFileArgs; } Compile(options, RedistVersionInfo.GetCompilerPath(provOptions, CompilerName), CompilerName, args, ref outputFile, ref retValue, trueArgs); results.NativeCompilerReturnValue = retValue; // only look for errors/warnings if the compile failed or the caller set the warning level if (retValue != 0 || options.WarningLevel > 0) { // The output of the compiler is in UTF8 string [] lines = ReadAllLines(outputFile, Encoding.UTF8, FileShare.ReadWrite); foreach (string line in lines) { results.Output.Add(line); ProcessCompilerOutputLine(results, line); } // Delete the empty assembly if we created one if (retValue != 0 && createdEmptyAssembly) File.Delete(options.OutputAssembly); } if (results.Errors.HasErrors || !options.GenerateInMemory) { results.PathToAssembly = options.OutputAssembly; return results; } // Read assembly into memory: byte[] assemblyBuff = File.ReadAllBytes(options.OutputAssembly); // Read symbol file into mempory and ignore any errors that may be encountered: // (This functionality was added in NetFx 4.5, errors must be ignored to ensure compatibility) byte[] symbolsBuff = null; try { String symbFileName = options.TempFiles.BasePath + "." + pdbname; if (File.Exists(symbFileName)) symbolsBuff = File.ReadAllBytes(symbFileName); } catch { symbolsBuff = null; } // Now get permissions and load assembly from buffer into the CLR: SecurityPermission perm = new SecurityPermission(SecurityPermissionFlag.ControlEvidence); perm.Assert(); try { #pragma warning disable 618 // Load with evidence is obsolete - this warning is passed on via the options.Evidence property results.CompiledAssembly = Assembly.Load(assemblyBuff, symbolsBuff, options.Evidence); #pragma warning restore 618 } finally { SecurityPermission.RevertAssert(); } return results; }
/// <summary> /// Retrieve the order in which columns appear /// </summary> /// <returns>Current display order of column indices</returns> protected int[] GetColumnOrder() { IntPtr lPar = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(int)) * Columns.Count); SecurityPermission perm = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode); // The method itself is attached with the security permission // Deny for unmanaged code, which will override // the Assert permission in this stack frame. perm.Assert(); IntPtr res = NativeMethods.SendMessage(Handle, NativeMethods.GetColumnOrderArray, new IntPtr(Columns.Count), lPar); if (res.ToInt32() == 0) // Something went wrong { Marshal.FreeHGlobal(lPar); return null; } int [] order = new int[Columns.Count]; Marshal.Copy(lPar, order, 0, Columns.Count); Marshal.FreeHGlobal(lPar); return order; }
private static string GetCurrentOEMCPEncoding(int code) { SecurityPermission sp = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode); sp.Assert();//Blessed Assert try { int cp = UnsafeNativeMethods.GetOEMCP(); return CharacterEncoding(cp, code); } finally { SecurityPermission.RevertAssert(); } }
private const int _COMPlusExceptionCode = unchecked((int)0xe0524f54); // Win32 exception code for COM+ exceptions internal virtual String InternalToString() { try { SecurityPermission sp= new SecurityPermission(SecurityPermissionFlag.ControlEvidence | SecurityPermissionFlag.ControlPolicy); sp.Assert(); } catch { } return ToString(); }
internal virtual string InternalToString() { try { SecurityPermission securityPermission = new SecurityPermission(SecurityPermissionFlag.ControlEvidence | SecurityPermissionFlag.ControlPolicy); securityPermission.Assert(); } catch { } bool needFileLineInfo = true; return this.ToString(needFileLineInfo); }
[System.Security.SecurityCritical] // auto-generated internal virtual String InternalToString() { try { #pragma warning disable 618 SecurityPermission sp= new SecurityPermission(SecurityPermissionFlag.ControlEvidence | SecurityPermissionFlag.ControlPolicy); #pragma warning restore 618 sp.Assert(); } catch { //under normal conditions there should be no exceptions //however if something wrong happens we still can call the usual ToString } // Get the current stack trace string. On CoreCLR we don't bother // to try and include file/line-number information because all AppDomains // are sandboxed, and so this won't succeed in most (or all) cases. Therefore the // Demand and exception overhead is a waste. // We currently have some bugs in watson bucket generation where the SecurityException // here causes us to lose saved bucket parameters. By not even doing the demand // we avoid those problems (although there are deep underlying problems that need to // be fixed there - relying on this to avoid problems is incomplete and brittle). bool fGetFileLineInfo = true; #if FEATURE_CORECLR fGetFileLineInfo = false; #endif return ToString(fGetFileLineInfo, true); }
private CompilerResults FromFileBatch(CompilerParameters options, string[] fileNames) { if( options == null) { throw new ArgumentNullException("options"); } if (fileNames == null) throw new ArgumentNullException("fileNames"); new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Demand(); string outputFile = null; int retValue = 0; CompilerResults results = new CompilerResults(options.TempFiles); SecurityPermission perm1 = new SecurityPermission(SecurityPermissionFlag.ControlEvidence); perm1.Assert(); try { results.Evidence = options.Evidence; } finally { SecurityPermission.RevertAssert(); } bool createdEmptyAssembly = false; if (options.OutputAssembly == null || options.OutputAssembly.Length == 0) { string extension = (options.GenerateExecutable) ? "exe" : "dll"; options.OutputAssembly = results.TempFiles.AddExtension(extension, !options.GenerateInMemory); // Create an empty assembly. This is so that the file will have permissions that // we can later access with our current credential. If we don't do this, the compiler // could end up creating an assembly that we cannot open. new FileStream(options.OutputAssembly, FileMode.Create, FileAccess.ReadWrite).Close(); createdEmptyAssembly = true; } string pdbname = "ildb"; // Don't delete pdbs when debug=false but they have specified pdbonly. if (options.CompilerOptions!= null && CultureInfo.InvariantCulture.CompareInfo.IndexOf(options.CompilerOptions,"/debug:pdbonly", CompareOptions.IgnoreCase) != -1) results.TempFiles.AddExtension(pdbname, true); else results.TempFiles.AddExtension(pdbname); string args = CmdArgsFromParameters(options) + " " + JoinStringArray(fileNames, " "); // Use a response file if the compiler supports it string responseFileArgs = GetResponseFileCmdArgs(options, args); string trueArgs = null; if (responseFileArgs != null) { trueArgs = args; args = responseFileArgs; } Compile(options, Executor.GetRuntimeInstallDirectory(), CompilerName, args, ref outputFile, ref retValue, trueArgs); results.NativeCompilerReturnValue = retValue; // only look for errors/warnings if the compile failed or the caller set the warning level if (retValue != 0 || options.WarningLevel > 0) { FileStream outputStream = new FileStream(outputFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite); try { if (outputStream.Length > 0) { // The output of the compiler is in UTF8 StreamReader sr = new StreamReader(outputStream, Encoding.UTF8); string line; do { line = sr.ReadLine(); if (line != null) { results.Output.Add(line); ProcessCompilerOutputLine(results, line); } } while (line != null); } } finally { outputStream.Close(); } // Delete the empty assembly if we created one if (retValue != 0 && createdEmptyAssembly) File.Delete(options.OutputAssembly); } if (!results.Errors.HasErrors && options.GenerateInMemory) { FileStream fs = new FileStream(options.OutputAssembly, FileMode.Open, FileAccess.Read, FileShare.Read); try { int fileLen = (int)fs.Length; byte[] b = new byte[fileLen]; fs.Read(b, 0, fileLen); SecurityPermission perm = new SecurityPermission(SecurityPermissionFlag.ControlEvidence); perm.Assert(); try { results.CompiledAssembly = Assembly.Load(b,null,options.Evidence); } finally { SecurityPermission.RevertAssert(); } } finally { fs.Close(); } } else { results.PathToAssembly = options.OutputAssembly; } return results; }
public void InstallAssembly(RegistrationConfig regConfig, object obSync) { Assembly asm = null; ApplicationSpec spec = null; CatalogSync sync = null; bool flag = false; bool flag2 = false; SecurityPermission permission = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode); try { permission.Demand(); permission.Assert(); ICatalogObject app = null; this.PrepArguments(regConfig); asm = this.NewLoadAssembly(regConfig.AssemblyFile); spec = new ApplicationSpec(asm, regConfig); if (spec.ConfigurableTypes == null) { regConfig.Application = null; regConfig.TypeLibrary = null; } else { if (obSync != null) { if (!(obSync is CatalogSync)) { throw new ArgumentException(Resource.FormatString("Err_obSync")); } sync = (CatalogSync) obSync; } this.PrepDriver(ref spec); string message = string.Empty; if (!this.ValidateBitness(spec, out message)) { throw new RegistrationException(message); } if ((regConfig.InstallationFlags & InstallationFlags.Register) != InstallationFlags.Default) { flag = !this.IsAssemblyRegistered(spec); this.ClassicRegistration(spec.Assembly); if ((regConfig.InstallationFlags & InstallationFlags.ExpectExistingTypeLib) != InstallationFlags.Default) { RegisterTypeLibrary(spec.TypeLib); } else { flag2 = true; GenerateTypeLibrary(spec.Assembly, spec.TypeLib, new Report(this.ReportWarning)); } } if (((regConfig.InstallationFlags & InstallationFlags.Install) != InstallationFlags.Default) && (spec.ConfigurableTypes != null)) { if ((regConfig.InstallationFlags & InstallationFlags.CreateTargetApplication) != InstallationFlags.Default) { app = this.CreateApplication(spec, true); } else if ((regConfig.InstallationFlags & InstallationFlags.FindOrCreateTargetApplication) != InstallationFlags.Default) { app = this.FindOrCreateApplication(spec, (regConfig.InstallationFlags & InstallationFlags.ReconfigureExistingApplication) != InstallationFlags.Default); } this.InstallTypeLibrary(spec); if (sync != null) { sync.Set(); } } if (((regConfig.InstallationFlags & InstallationFlags.Configure) != InstallationFlags.Default) && (spec.ConfigurableTypes != null)) { this.ConfigureComponents(spec); if (sync != null) { sync.Set(); } } if (app != null) { this.PostProcessApplication(app, spec); } this.CleanupDriver(); } } catch (Exception exception) { if ((exception is NullReferenceException) || (exception is SEHException)) { throw; } if (((exception is SecurityException) || (exception is UnauthorizedAccessException)) || ((exception.InnerException != null) && ((exception.InnerException is SecurityException) || (exception.InnerException is UnauthorizedAccessException)))) { exception = new RegistrationException(Resource.FormatString("Reg_Unauthorized"), exception); } if (flag && (null != asm)) { try { this.ClassicUnregistration(asm); } catch (Exception exception2) { if ((exception2 is NullReferenceException) || (exception2 is SEHException)) { throw; } } } if (flag2 && (null != asm)) { try { this.UnregisterTypeLib(asm); } catch (Exception exception3) { if ((exception3 is NullReferenceException) || (exception3 is SEHException)) { throw; } } } throw exception; } }
private void rtfcontrol_Load(object sender, System.EventArgs e) { //new FileIOPermission(PermissionState.Unrestricted).Assert(); PrincipalPermission P = new PrincipalPermission(PermissionState.Unrestricted); if(!P.IsUnrestricted()) Msg("Assigning Principal failed!"); else Msg("Assigning Principal passed!!"); SecurityPermission SP = new SecurityPermission(PermissionState.Unrestricted); if(!SP.IsUnrestricted()) Msg("Assigning SecurityPermission failed!"); else Msg("Assigning SecurityPermission passed!!"); try { SP.Assert(); } catch(Exception Err) { throw new Exception(Err.Message,Err.InnerException); } ListViewItem LVI = listView1.Items.Add(System.DateTime.Now.ToShortTimeString()); LVI.SubItems.Add("Contacting Server please wait..."); CodeAccessPermission.RevertAssert(); }
public void UninstallAssembly(RegistrationConfig regConfig, object obSync) { CatalogSync sync = null; SecurityPermission permission = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode); permission.Demand(); permission.Assert(); if (obSync != null) { if (!(obSync is CatalogSync)) { throw new ArgumentException(Resource.FormatString("Err_obSync")); } sync = (CatalogSync) obSync; } Assembly asm = this.NewLoadAssembly(regConfig.AssemblyFile); ApplicationSpec spec = new ApplicationSpec(asm, regConfig); if (spec.ConfigurableTypes != null) { this.PrepDriver(ref spec); if (spec.ConfigurableTypes != null) { ICatalogObject obj2 = this.FindApplication(this._appColl, spec); if (obj2 == null) { throw new RegistrationException(Resource.FormatString("Reg_AppNotFoundErr", spec)); } ICatalogCollection collection = (ICatalogCollection) this._appColl.GetCollection(CollectionName.Components, obj2.Key()); string[] arr = new string[spec.ConfigurableTypes.Length]; int index = 0; foreach (Type type in spec.ConfigurableTypes) { arr[index] = Marshal.GenerateGuidForType(type).ToString(); index++; } Populate(collection); bool flag = true; int lIndex = 0; while (lIndex < collection.Count()) { ICatalogObject obj3 = (ICatalogObject) collection.Item(lIndex); string g = (string) obj3.Key(); g = new Guid(g).ToString(); if (this.FindIndexOf(arr, g) != -1) { collection.Remove(lIndex); if (sync != null) { sync.Set(); } } else { lIndex++; flag = false; } } SaveChanges(collection); if (flag) { for (int i = 0; i < this._appColl.Count(); i++) { ICatalogObject obj4 = (ICatalogObject) this._appColl.Item(i); if (obj4.Key().Equals(obj2.Key())) { this._appColl.Remove(i); if (sync != null) { sync.Set(); } break; } } SaveChanges(this._appColl); } } this.UnregisterAssembly(asm, spec); this.CleanupDriver(); } }
private void RegisterAsSponsor() { ILease baseLease = (ILease)GetLifetimeService(); if (baseLease != null) { // Assert permission to register as a sponsor for this lease. This is needed for the Internet permission level. SecurityPermission permission = new SecurityPermission(SecurityPermissionFlag.RemotingConfiguration); permission.Assert(); try { // register for sponsorship baseLease.Register(this); } finally { CodeAccessPermission.RevertAssert(); } } // baseLease == null when we are not in a separate appdomain }
private void AppDomainUnload() { // assert is needed for the Internet named permission set. SecurityPermission permission = new SecurityPermission(SecurityPermissionFlag.ControlAppDomain); permission.Assert(); // Sadly, AppDomains can refuse to unload under certain circumstances - mainly when threads get stuck in native code. // If that happens, we will retry with increasing intervals. // Other exceptions can also happen, in which case, we will trace the error message and quiety leave, otherwise the process might be torn down // and this is never what we want as the user has no way to catch anything thrown by this thread. try { for (int wait = 0; wait < MaxAppDomainUnloadWaits; wait++) { try { AppDomain.Unload(AppDomain.CurrentDomain); // if we get here successfully, we have unloaded the AppDomain, and thus life is good return; } catch (CannotUnloadAppDomainException) { // Double the interval and wait Thread.Sleep(1 << wait); } } // We end up here if all retries failed. We try once more, and if that throws - so be it. // The outer handler will eat it and trace it out Thread.Sleep(1 << MaxAppDomainUnloadWaits); AppDomain.Unload(AppDomain.CurrentDomain); } // We are unloading our own AppDomain so one of these two will typically happen. They actually indicate success, and we don't need to report these catch (AppDomainUnloadedException) { } catch (ThreadAbortException) { } // If we got here, this means that either we are done trying to unload or something unexpected happened during the unload. We trace that out catch (Exception ex) { Trace.WriteLine(String.Format(System.Globalization.CultureInfo.CurrentCulture, Res.FailedToUnloadAppDomain, AppDomain.CurrentDomain.FriendlyName, ex.Message)); } }
public void RevokeLifetimeToken(int token) { lock (m_lifetimeTokens) { if (!m_lifetimeTokens.Remove(token)) throw new InvalidOperationException(Res.LifetimeTokenNotFound); if (m_lifetimeTokens.Count == 0) { m_zeroReferencesLeft = true; // hook to allow subclasses to clean up OnFinalRevoke(); IContract owner = ContractHandle.AppDomainOwner(AppDomain.CurrentDomain); if (owner != null) { if (owner == this) { // Create a separate thread to unload this appdomain, because we // cannot shut down an appdomain from the Finalizer thread (though there // is a bug that allows us to do so after the first appdomain has been // unloaded, but let's not rely on that). // We can consider using an threadpool thread to do this, but that would add // test burden. SecurityPermission permission = new SecurityPermission(SecurityPermissionFlag.ControlThread); permission.Assert(); System.Threading.ThreadStart threadDelegate = new System.Threading.ThreadStart(AppDomainUnload); System.Threading.Thread unloaderThread = new System.Threading.Thread(threadDelegate); unloaderThread.Start(); } else owner.RevokeLifetimeToken(m_tokenOfAppdomainOwner); } } } }
// Render the contents of the RichTextBox for printing // Return the last character printed + 1 (printing start from this point for next page) public int Print(int charFrom, int charTo, Graphics gr, Rectangle bounds) { //Calculate the area to render and print RECT rectToPrint; rectToPrint.Top = (int)(bounds.Top * anInch); rectToPrint.Bottom = (int)(bounds.Height * anInch);// (int)(bounds.Bottom * anInch); rectToPrint.Left = (int)(bounds.Left * anInch); rectToPrint.Right = (int)(bounds.Width * anInch);// (int)(bounds.Right * anInch); //Calculate the size of the page RECT rectPage; rectPage.Top = (int)(bounds.Top * anInch); rectPage.Bottom = (int)(gr.ClipBounds.Height * anInch);//(int)(bounds.Bottom * anInch); rectPage.Left = (int)(bounds.Left * anInch); rectPage.Right = (int)(gr.ClipBounds.Right * anInch);//(int)(bounds.Right * anInch); IntPtr hdc = gr.GetHdc(); FORMATRANGE fmtRange; fmtRange.chrg.cpMax = charTo; //Indicate character from to character to fmtRange.chrg.cpMin = charFrom; fmtRange.hdc = hdc; //Use the same DC for measuring and rendering fmtRange.hdcTarget = hdc; //Point at printer hDC fmtRange.rc = rectToPrint; //Indicate the area on page to print fmtRange.rcPage = rectPage; //Indicate size of page IntPtr res = IntPtr.Zero; IntPtr wparam = IntPtr.Zero; wparam = new IntPtr(1); //Get the pointer to the FORMATRANGE structure in memory IntPtr lparam = IntPtr.Zero; lparam = Marshal.AllocCoTaskMem(Marshal.SizeOf(fmtRange)); Marshal.StructureToPtr(fmtRange, lparam, false); //System.Security.Permissions.SecurityPermission, mscorlib SecurityPermission secPerm = new SecurityPermission(PermissionState.Unrestricted); secPerm.Assert(); //Send the rendered data for printing res = SendMessage(Handle, EM_FORMATRANGE, wparam, lparam); //Free the block of memory allocated Marshal.FreeCoTaskMem(lparam); //Release the device context handle obtained by a previous call gr.ReleaseHdc(hdc); //Return last + 1 character printer return res.ToInt32(); }
private void StartRaisingEvents() { //Cannot allocate the directoryHandle and the readBuffer if the object has been disposed; finalization has been suppressed. if (this.disposed) throw new ObjectDisposedException(GetType().Name); try { new EnvironmentPermission(PermissionState.Unrestricted).Assert(); if (Environment.OSVersion.Platform != PlatformID.Win32NT) { throw new PlatformNotSupportedException(SR.GetString(SR.WinNTRequired)); } } finally { CodeAccessPermission.RevertAssert(); } // If we're called when "Initializing" is true, set enabled to true if (IsSuspended()) { enabled = true; return; } if (!readGranted) { string fullPath; // Consider asserting path discovery permission here. fullPath = System.IO.Path.GetFullPath(directory); FileIOPermission permission = new FileIOPermission(FileIOPermissionAccess.Read, fullPath); permission.Demand(); readGranted = true; } // If we're attached, don't do anything. if (!IsHandleInvalid) { return; } // Create handle to directory being monitored directoryHandle = NativeMethods.CreateFile(directory, // Directory name UnsafeNativeMethods.FILE_LIST_DIRECTORY, // access (read-write) mode UnsafeNativeMethods.FILE_SHARE_READ | UnsafeNativeMethods.FILE_SHARE_DELETE | UnsafeNativeMethods.FILE_SHARE_WRITE, // share mode null, // security descriptor UnsafeNativeMethods.OPEN_EXISTING, // how to create UnsafeNativeMethods.FILE_FLAG_BACKUP_SEMANTICS | UnsafeNativeMethods.FILE_FLAG_OVERLAPPED, // file attributes new SafeFileHandle(IntPtr.Zero, false) // file with attributes to copy ); if (IsHandleInvalid) { throw new FileNotFoundException(SR.GetString(SR.FSW_IOError, directory)); } stopListening = false; // Start ignoring all events that were initiated before this. Interlocked.Increment(ref currentSession); // Attach handle to thread pool //SECREVIEW: At this point at least FileIOPermission has already been demanded. SecurityPermission secPermission = new SecurityPermission(PermissionState.Unrestricted); secPermission.Assert(); try { ThreadPool.BindHandle(directoryHandle); } finally { SecurityPermission.RevertAssert(); } enabled = true; // Setup IO completion port Monitor(null); }
private object OnUnregisterTextStore(object arg) { UnsafeNativeMethods.ITfContext context; UnsafeNativeMethods.ITfSource source; if ((_threadManager == null) || (_threadManager.Value == null)) { return null; } SecurityPermission secperm = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode); TextStore textstore = (TextStore)arg; // We don't have to release Dispatcher. // These Cicero COM calls could be marshalled when UnregisterTextStore is called from // TextEditor's Finalizer through TextStore.OnDetach. GC Thread does not take Dispatcher. if (textstore.ThreadFocusCookie != UnsafeNativeMethods.TF_INVALID_COOKIE) { source = _threadManager.Value as UnsafeNativeMethods.ITfSource; source.UnadviseSink(textstore.ThreadFocusCookie); textstore.ThreadFocusCookie = UnsafeNativeMethods.TF_INVALID_COOKIE; } textstore.DocumentManager.GetBase(out context); if (context != null) { if (textstore.EditSinkCookie != UnsafeNativeMethods.TF_INVALID_COOKIE) { source = context as UnsafeNativeMethods.ITfSource; source.UnadviseSink(textstore.EditSinkCookie); textstore.EditSinkCookie = UnsafeNativeMethods.TF_INVALID_COOKIE; } Marshal.ReleaseComObject(context); } secperm.Assert(); try { textstore.DocumentManager.Pop(UnsafeNativeMethods.PopFlags.TF_POPF_ALL); } finally { SecurityPermission.RevertAssert(); } Marshal.ReleaseComObject(textstore.DocumentManager); textstore.DocumentManager = null; Debug.Assert(_registeredtextstorecount > 0, "Overrelease TextStore!"); _registeredtextstorecount--; // If Dispatcher is finished and the last textstore // is unregistered, we don't need ThreadManager any more. Deactivate and release it. // We keep ThreadManager active as long as Dispatcher is alive even if // _registeredtextstorecount is 0. if (_isDispatcherShutdownFinished && (_registeredtextstorecount == 0)) { DeactivateThreadManager(); } return null; }
internal void ConfigureCollection(ICatalogCollection coll, IConfigCallback cb) { bool flag = false; SecurityPermission permission = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode); permission.Demand(); permission.Assert(); foreach (object obj2 in cb) { object a = cb.FindObject(coll, obj2); cb.ConfigureDefaults(a, obj2); } SaveChanges(coll); flag = false; foreach (object obj4 in cb) { object obj5 = cb.FindObject(coll, obj4); if (cb.Configure(obj5, obj4)) { flag = true; } } SaveChanges(coll); flag = false; foreach (object obj6 in cb) { object obj7 = cb.FindObject(coll, obj6); if (cb.AfterSaveChanges(obj7, obj6)) { flag = true; } } if (flag) { SaveChanges(coll); } cb.ConfigureSubCollections(coll); }
internal static Win32Exception CreateSafeWin32Exception(int error) { Win32Exception result = null; SecurityPermission securityPermission = new SecurityPermission(PermissionState.Unrestricted); securityPermission.Assert(); try { if (error == 0) { result = new Win32Exception(); } else { result = new Win32Exception(error); } } finally { CodeAccessPermission.RevertAssert(); } return result; }
protected override CompilerResults FromFileBatch(CompilerParameters options, string[] fileNames) { if( options == null) { throw new ArgumentNullException("options"); } if (fileNames == null) throw new ArgumentNullException("fileNames"); new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Demand(); string outputFile = null; int retValue = 0; CompilerResults results = new CompilerResults(options.TempFiles); SecurityPermission perm1 = new SecurityPermission(SecurityPermissionFlag.ControlEvidence); perm1.Assert(); try { #pragma warning disable 618 results.Evidence = options.Evidence; #pragma warning restore 618 } finally { SecurityPermission.RevertAssert(); } bool createdEmptyAssembly = false; string extension = (options.GenerateExecutable) ? "exe" : "dll"; string extensionWithDot = '.' + extension; if (options.OutputAssembly == null || options.OutputAssembly.Length == 0) { options.OutputAssembly = results.TempFiles.AddExtension(extension, !options.GenerateInMemory); // Create an empty assembly. This is so that the file will have permissions that // we can later access with our current credential.< new FileStream(options.OutputAssembly, FileMode.Create, FileAccess.ReadWrite).Close(); createdEmptyAssembly = true; } String outputAssemblyFile = options.OutputAssembly; if (!Path.GetExtension(outputAssemblyFile).Equals(extensionWithDot, StringComparison.OrdinalIgnoreCase)) { // The vb compiler automatically appends the 'dll' or 'exe' extension if it's not present. // We similarly determine the file name, so we can find it later. outputAssemblyFile += extensionWithDot; } #if FEATURE_PAL string pdbname = "ildb"; #else string pdbname = "pdb"; #endif // hack so that we don't delete pdbs when debug=false but they have specified pdbonly. if (options.CompilerOptions!= null && options.CompilerOptions.IndexOf("/debug:pdbonly", StringComparison.OrdinalIgnoreCase) != -1) results.TempFiles.AddExtension(pdbname, true); else results.TempFiles.AddExtension(pdbname); string args = CmdArgsFromParameters(options) + " " + JoinStringArray(fileNames, " "); // Use a response file if the compiler supports it string responseFileArgs = GetResponseFileCmdArgs(options, args); string trueArgs = null; if (responseFileArgs != null) { trueArgs = args; args = responseFileArgs; } Compile(options, RedistVersionInfo.GetCompilerPath(provOptions, CompilerName), CompilerName, args, ref outputFile, ref retValue, trueArgs); results.NativeCompilerReturnValue = retValue; // only look for errors/warnings if the compile failed or the caller set the warning level if (retValue != 0 || options.WarningLevel > 0) { // The VB Compiler generates multi-line error messages. Currently, the best way to obtain the // full message without going too far, is to use the distinction between \n and \r\n. // For multi-line error messages, the former is always output between lines of an error message, // and the latter is output at the end. So this rearranges the output of File.ReadAllLines // so that an error message is contained on a line. // // As of now, this is the best way to match a full error message. This is because the compiler // may output other trailing data which isn't an error msg or warning, but doesn't belong to // the error message. So trailing data could get tacked on since the message doesn't always end // with punctuation or some other marker. I confirmed this with the VBC group. byte[] fileBytes = ReadAllBytes(outputFile, FileShare.ReadWrite); // The output of the compiler is in UTF8 string fileStr = Encoding.UTF8.GetString(fileBytes); // Split lines only around \r\n (see above) string[] lines = Regex.Split(fileStr, @"\r\n"); foreach (string line in lines) { results.Output.Add(line); ProcessCompilerOutputLine(results, line); } // Delete the empty assembly if we created one if (retValue != 0 && createdEmptyAssembly) File.Delete(outputAssemblyFile); } if (!results.Errors.HasErrors && options.GenerateInMemory) { FileStream fs = new FileStream(outputAssemblyFile, FileMode.Open, FileAccess.Read, FileShare.Read); try { int fileLen = (int)fs.Length; byte[] b = new byte[fileLen]; fs.Read(b, 0, fileLen); SecurityPermission perm = new SecurityPermission(SecurityPermissionFlag.ControlEvidence); perm.Assert(); try { #pragma warning disable 618 // Load with evidence is obsolete - this warning is passed on via the options.Evidence parameter results.CompiledAssembly = Assembly.Load(b,null,options.Evidence); #pragma warning restore 618 } finally { SecurityPermission.RevertAssert(); } } finally { fs.Close(); } } else { results.PathToAssembly = outputAssemblyFile; } return results; }
private void OpenSqlFileStream ( string path, byte[] transactionContext, System.IO.FileAccess access, System.IO.FileOptions options, Int64 allocationSize ) { //----------------------------------------------------------------- // precondition validation // these should be checked by any caller of this method // ensure we have validated and normalized the path before Debug.Assert ( path != null ); Debug.Assert (transactionContext != null); if (access != FileAccess.Read && access != FileAccess.Write && access != FileAccess.ReadWrite) throw ADP.ArgumentOutOfRange ("access"); // FileOptions is a set of flags, so AND the given value against the set of values we do not support if ( ( options & ~( FileOptions.WriteThrough | FileOptions.Asynchronous | FileOptions.RandomAccess | FileOptions.SequentialScan ) ) != 0 ) throw ADP.ArgumentOutOfRange ( "options" ); //----------------------------------------------------------------- // normalize the provided path // * compress path to remove any occurences of '.' or '..' // * trim whitespace from the beginning and end of the path // * ensure that the path starts with '\\' // * ensure that the path does not start with '\\.\' // * ensure that the path is not longer than Int16.MaxValue path = GetFullPathInternal ( path ); // ensure the running code has permission to read/write the file DemandAccessPermission(path, access); FileFullEaInformation eaBuffer = null; SecurityQualityOfService qos = null; UnicodeString objectName = null; Microsoft.Win32.SafeHandles.SafeFileHandle hFile = null; int nDesiredAccess = UnsafeNativeMethods.FILE_READ_ATTRIBUTES | UnsafeNativeMethods.SYNCHRONIZE; UInt32 dwCreateOptions = 0; UInt32 dwCreateDisposition = 0; System.IO.FileShare shareAccess = System.IO.FileShare.None; switch (access) { case System.IO.FileAccess.Read: nDesiredAccess |= UnsafeNativeMethods.FILE_READ_DATA; shareAccess = System.IO.FileShare.Delete | System.IO.FileShare.ReadWrite; dwCreateDisposition = (uint) UnsafeNativeMethods.CreationDisposition.FILE_OPEN; break; case System.IO.FileAccess.Write: nDesiredAccess |= UnsafeNativeMethods.FILE_WRITE_DATA; shareAccess = System.IO.FileShare.Delete | System.IO.FileShare.Read; dwCreateDisposition = (uint) UnsafeNativeMethods.CreationDisposition.FILE_OVERWRITE; break; case System.IO.FileAccess.ReadWrite: default: // we validate the value of 'access' parameter in the beginning of this method Debug.Assert(access == System.IO.FileAccess.ReadWrite); nDesiredAccess |= UnsafeNativeMethods.FILE_READ_DATA | UnsafeNativeMethods.FILE_WRITE_DATA; shareAccess = System.IO.FileShare.Delete | System.IO.FileShare.Read; dwCreateDisposition = (uint) UnsafeNativeMethods.CreationDisposition.FILE_OVERWRITE; break; } if ((options & System.IO.FileOptions.WriteThrough) != 0) { dwCreateOptions |= (uint) UnsafeNativeMethods.CreateOption.FILE_WRITE_THROUGH; } if ((options & System.IO.FileOptions.Asynchronous) == 0) { dwCreateOptions |= (uint) UnsafeNativeMethods.CreateOption.FILE_SYNCHRONOUS_IO_NONALERT; } if ((options & System.IO.FileOptions.SequentialScan) != 0) { dwCreateOptions |= (uint) UnsafeNativeMethods.CreateOption.FILE_SEQUENTIAL_ONLY; } if ( (options & System.IO.FileOptions.RandomAccess) != 0) { dwCreateOptions |= (uint) UnsafeNativeMethods.CreateOption.FILE_RANDOM_ACCESS; } try { eaBuffer = new FileFullEaInformation(transactionContext); qos = new SecurityQualityOfService(UnsafeNativeMethods.SecurityImpersonationLevel.SecurityAnonymous, false, false); // NOTE: the Name property is intended to reveal the publicly available moniker for the // FILESTREAM attributed column data. We will not surface the internal processing that // takes place to create the mappedPath. string mappedPath = InitializeNtPath(path); objectName = new UnicodeString(mappedPath); UnsafeNativeMethods.OBJECT_ATTRIBUTES oa; oa.length = Marshal.SizeOf(typeof(UnsafeNativeMethods.OBJECT_ATTRIBUTES)); oa.rootDirectory = IntPtr.Zero; oa.attributes = (int)UnsafeNativeMethods.Attributes.CaseInsensitive; oa.securityDescriptor = IntPtr.Zero; oa.securityQualityOfService = qos; oa.objectName = objectName; UnsafeNativeMethods.IO_STATUS_BLOCK ioStatusBlock; uint oldMode; uint retval = 0; UnsafeNativeMethods.SetErrorModeWrapper ( UnsafeNativeMethods.SEM_FAILCRITICALERRORS, out oldMode ); try { Bid.Trace("<sc.SqlFileStream.OpenSqlFileStream|ADV> %d#, desiredAccess=0x%08x, allocationSize=%I64d, fileAttributes=0x%08x, shareAccess=0x%08x, dwCreateDisposition=0x%08x, createOptions=0x%08x\n", ObjectID, (int) nDesiredAccess, allocationSize, 0, (int) shareAccess, dwCreateDisposition, dwCreateOptions ); retval = UnsafeNativeMethods.NtCreateFile(out hFile, nDesiredAccess, ref oa, out ioStatusBlock, ref allocationSize, 0, shareAccess, dwCreateDisposition, dwCreateOptions, eaBuffer, (uint) eaBuffer.Length); } finally { UnsafeNativeMethods.SetErrorModeWrapper( oldMode, out oldMode ); } switch ( retval ) { case 0: break; case UnsafeNativeMethods.STATUS_SHARING_VIOLATION: throw ADP.InvalidOperation ( Res.GetString ( Res.SqlFileStream_FileAlreadyInTransaction ) ); case UnsafeNativeMethods.STATUS_INVALID_PARAMETER: throw ADP.Argument ( Res.GetString ( Res.SqlFileStream_InvalidParameter ) ); case UnsafeNativeMethods.STATUS_OBJECT_NAME_NOT_FOUND: { System.IO.DirectoryNotFoundException e = new System.IO.DirectoryNotFoundException(); ADP.TraceExceptionAsReturnValue ( e ); throw e; } default: { uint error = UnsafeNativeMethods.RtlNtStatusToDosError ( retval ); if ( error == UnsafeNativeMethods.ERROR_MR_MID_NOT_FOUND ) { // status code could not be mapped to a Win32 error code error = retval; } System.ComponentModel.Win32Exception e = new System.ComponentModel.Win32Exception ( unchecked ( (int) error ) ); ADP.TraceExceptionAsReturnValue ( e ); throw e; } } if ( hFile.IsInvalid ) { System.ComponentModel.Win32Exception e = new System.ComponentModel.Win32Exception ( UnsafeNativeMethods.ERROR_INVALID_HANDLE ); ADP.TraceExceptionAsReturnValue ( e ); throw e; } UnsafeNativeMethods.FileType fileType = UnsafeNativeMethods.GetFileType(hFile); if (fileType != UnsafeNativeMethods.FileType.Disk) { hFile.Dispose(); throw ADP.Argument ( Res.GetString ( Res.SqlFileStream_PathNotValidDiskResource ) ); } // if the user is opening the SQL FileStream in read/write mode, we assume that they want to scan // through current data and then append new data to the end, so we need to tell SQL Server to preserve // the existing file contents. if ( access == System.IO.FileAccess.ReadWrite ) { uint ioControlCode = UnsafeNativeMethods.CTL_CODE ( UnsafeNativeMethods.FILE_DEVICE_FILE_SYSTEM, IoControlCodeFunctionCode, (byte) UnsafeNativeMethods.Method.METHOD_BUFFERED, (byte) UnsafeNativeMethods.Access.FILE_ANY_ACCESS); uint cbBytesReturned = 0; if ( !UnsafeNativeMethods.DeviceIoControl ( hFile, ioControlCode, IntPtr.Zero, 0, IntPtr.Zero, 0, out cbBytesReturned, IntPtr.Zero ) ) { System.ComponentModel.Win32Exception e = new System.ComponentModel.Win32Exception ( Marshal.GetLastWin32Error() ); ADP.TraceExceptionAsReturnValue ( e ); throw e; } } // now that we've successfully opened a handle on the path and verified that it is a file, // use the SafeFileHandle to initialize our internal System.IO.FileStream instance // NOTE: need to assert UnmanagedCode permissions for this constructor. This is relatively benign // in that we've done much the same validation as in the FileStream(string path, ...) ctor case // most notably, validating that the handle type corresponds to an on-disk file. bool bRevertAssert = false; try { SecurityPermission sp = new SecurityPermission ( SecurityPermissionFlag.UnmanagedCode ); sp.Assert(); bRevertAssert = true; System.Diagnostics.Debug.Assert ( m_fs == null ); #if MOBILE m_fs = new System.IO.FileStream ( hFile.DangerousGetHandle (), access, ( ( options & System.IO.FileOptions.Asynchronous ) != 0 ), DefaultBufferSize ); #else m_fs = new System.IO.FileStream ( hFile, access, DefaultBufferSize, ( ( options & System.IO.FileOptions.Asynchronous ) != 0 ) ); #endif } finally { if ( bRevertAssert ) SecurityPermission.RevertAssert(); } } catch { if ( hFile != null && !hFile.IsInvalid ) hFile.Dispose(); throw; } finally { if (eaBuffer != null) { eaBuffer.Dispose(); eaBuffer = null; } if (qos != null) { qos.Dispose(); qos = null; } if (objectName != null) { objectName.Dispose(); objectName = null; } } }
private static Uri GetDeploymentUri() { Invariant.Assert(ApplicationDeployment.IsNetworkDeployed); AppDomain currentDomain = AppDomain.CurrentDomain; ApplicationIdentity ident = null; string codeBase = null; SecurityPermission p1 = new SecurityPermission(SecurityPermissionFlag.ControlDomainPolicy); p1.Assert(); try { ident = currentDomain.ApplicationIdentity; // ControlDomainPolicy } finally { CodeAccessPermission.RevertAssert(); } SecurityPermission p2 = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode); p2.Assert(); try { codeBase = ident.CodeBase; // Unmanaged Code permission } finally { CodeAccessPermission.RevertAssert(); } return new Uri(new Uri(codeBase), new Uri(".", UriKind.Relative)); }
[System.Security.SecurityCritical] // auto-generated internal virtual String InternalToString() { try { #pragma warning disable 618 SecurityPermission sp= new SecurityPermission(SecurityPermissionFlag.ControlEvidence | SecurityPermissionFlag.ControlPolicy); #pragma warning restore 618 sp.Assert(); } catch { //under normal conditions there should be no exceptions //however if something wrong happens we still can call the usual ToString } // Get the current stack trace string. return ToString(true, true); }
internal void UnloadAppDomain() { if (Process.IsCurrentProcess) { SecurityPermission permission = new SecurityPermission(SecurityPermissionFlag.ControlAppDomain); permission.Assert(); AppDomain.Unload(AppDomain); CodeAccessPermission.RevertAssert(); } else { try { _addInServerWorker.UnloadAppDomain(); } catch (AppDomainUnloadedException) { } catch (RemotingException) { } } }