public void StartPipeServer()
{
try
{
Task serverTask = Task.Factory.StartNew(() =>
{
PipeSecurity ps = new PipeSecurity();
System.Security.Principal.SecurityIdentifier sid = new System.Security.Principal.SecurityIdentifier(System.Security.Principal.WellKnownSidType.BuiltinUsersSid, null);
PipeAccessRule par = new PipeAccessRule(sid, PipeAccessRights.ReadWrite, System.Security.AccessControl.AccessControlType.Allow);
ps.AddAccessRule(par);
var server = new NamedPipeServerStream("ForecourtToPumpSim", PipeDirection.InOut, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous, 1024, 1024, ps);
Console.WriteLine("Waiting for client connection...");
server.WaitForConnection();
StreamReader serverReader = new StreamReader(server);
StreamWriter serverWriter = new StreamWriter(server);
ConnectedEvent.Set();
while (true)
{
string line = serverReader.ReadLine();
string response = "";
HandleForecourtMessages(line, ref response);
serverWriter.WriteLine(response);
serverWriter.Flush();
}
});
}
catch (IOException e)
{
}
}
public async Task <Connection> ActivateAsync(CancellationToken token)
{
ProcessStartInfo info = new ProcessStartInfo();
var programPath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "Server", @"LanguageServerWithUI.exe");
info.FileName = programPath;
info.WorkingDirectory = Path.GetDirectoryName(programPath);
var stdInPipeName = @"output";
var stdOutPipeName = @"input";
var pipeAccessRule = new PipeAccessRule("Everyone", PipeAccessRights.ReadWrite, System.Security.AccessControl.AccessControlType.Allow);
var pipeSecurity = new PipeSecurity();
pipeSecurity.AddAccessRule(pipeAccessRule);
var bufferSize = 256;
var readerPipe = new NamedPipeServerStream(stdInPipeName, PipeDirection.InOut, 4, PipeTransmissionMode.Message, PipeOptions.Asynchronous, bufferSize, bufferSize, pipeSecurity);
var writerPipe = new NamedPipeServerStream(stdOutPipeName, PipeDirection.InOut, 4, PipeTransmissionMode.Message, PipeOptions.Asynchronous, bufferSize, bufferSize, pipeSecurity);
Process process = new Process();
process.StartInfo = info;
if (process.Start())
{
await readerPipe.WaitForConnectionAsync(token);
await writerPipe.WaitForConnectionAsync(token);
return(new Connection(readerPipe, writerPipe));
}
return(null);
}
internal static PipeSecurity?CreatePipeSecurity()
{
if (PlatformInformation.IsRunningOnMono)
{
// Pipe security and additional access rights constructor arguments
// are not supported by Mono
// https://github.com/dotnet/roslyn/pull/30810
// https://github.com/mono/mono/issues/11406
return(null);
}
var security = new PipeSecurity();
SecurityIdentifier identifier = WindowsIdentity.GetCurrent().Owner;
// Restrict access to just this account.
PipeAccessRule rule = new PipeAccessRule(
identifier,
PipeAccessRights.ReadWrite | PipeAccessRights.CreateNewInstance,
AccessControlType.Allow
);
security.AddAccessRule(rule);
security.SetOwner(identifier);
return(security);
}
private static NamedPipeServerStream CreateServer(string pipeName)
{
// Create a new pipe accessible by local authenticated users, disallow network
var sidNetworkService = new SecurityIdentifier(WellKnownSidType.NetworkServiceSid, null);
var sidWorld = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
var pipeSecurity = new PipeSecurity();
// Alow Everyone to read/write to pipe
var accessRule = new PipeAccessRule(sidWorld, PipeAccessRights.ReadWrite, AccessControlType.Allow);
pipeSecurity.AddAccessRule(accessRule);
// Deny network access to the named pipe
accessRule = new PipeAccessRule(sidNetworkService, PipeAccessRights.ReadWrite, AccessControlType.Deny);
pipeSecurity.AddAccessRule(accessRule);
// Create pipe
return(new NamedPipeServerStream(
pipeName,
PipeDirection.In,
1,
PipeTransmissionMode.Byte,
PipeOptions.Asynchronous,
0,
0,
pipeSecurity));
}
/// <summary>
/// Create an instance of the pipe. This might be the first instance, or a subsequent instance.
/// There always needs to be an instance of the pipe created to listen for a new client connection.
/// </summary>
/// <returns>The pipe instance or throws an exception.</returns>
private NamedPipeServerStream ConstructPipe(string pipeName)
{
CompilerServerLogger.Log("Constructing pipe '{0}'.", pipeName);
SecurityIdentifier identifier = WindowsIdentity.GetCurrent().Owner;
PipeSecurity security = new PipeSecurity();
// Restrict access to just this account.
PipeAccessRule rule = new PipeAccessRule(identifier, PipeAccessRights.ReadWrite | PipeAccessRights.CreateNewInstance, AccessControlType.Allow);
security.AddAccessRule(rule);
security.SetOwner(identifier);
NamedPipeServerStream pipeStream = new NamedPipeServerStream(
pipeName,
PipeDirection.InOut,
NamedPipeServerStream.MaxAllowedServerInstances, // Maximum connections.
PipeTransmissionMode.Byte,
PipeOptions.Asynchronous | PipeOptions.WriteThrough,
PipeBufferSize, // Default input buffer
PipeBufferSize, // Default output buffer
security,
HandleInheritability.None);
CompilerServerLogger.Log("Successfully constructed pipe '{0}'.", pipeName);
return(pipeStream);
}
public MainWindowViewModel()
{
var stdInPipeName = @"input";
var stdOutPipeName = @"output";
var pipeAccessRule = new PipeAccessRule("Everyone", PipeAccessRights.ReadWrite, System.Security.AccessControl.AccessControlType.Allow);
var pipeSecurity = new PipeSecurity();
pipeSecurity.AddAccessRule(pipeAccessRule);
var readerPipe = new NamedPipeClientStream(stdInPipeName);
var writerPipe = new NamedPipeClientStream(stdOutPipeName);
readerPipe.Connect();
writerPipe.Connect();
this.InitializedMessage = "The server has not yet been initialized.";
this.languageServer = new LanguageServer.LanguageServer(writerPipe, readerPipe);
this.languageServer.OnInitialized += OnInitialized;
this.languageServer.Disconnected += OnDisconnected;
this.languageServer.PropertyChanged += OnLanguageServerPropertyChanged;
DiagnosticItems.Add(new DiagnosticItem());
this.LogMessage = string.Empty;
this.ResponseText = string.Empty;
this.MessageRequestOptions = "3";
}
private void ReadData()
{
var pipeSecurity = new PipeSecurity();
var everyoneSecurityIdentifier = new SecurityIdentifier(
WellKnownSidType.WorldSid, null);
var everyoneAccessRule = new PipeAccessRule(everyoneSecurityIdentifier,
PipeAccessRights.FullControl, AccessControlType.Allow);
pipeSecurity.AddAccessRule(everyoneAccessRule);
using (var namedPipeServer = new NamedPipeServerStream(
_serverPipeConfiguration.Name, PipeDirection.InOut, 1,
PipeTransmissionMode.Byte, PipeOptions.Asynchronous,
0, 0, pipeSecurity))
{
while (true)
{
if (_stopReading)
{
return;
}
ReadMessage(namedPipeServer);
}
}
}
/// <summary>
/// Starts a new Pipe server on a new thread
/// </summary>
public void StartServer()
{
StopServer();
Thread = new Thread((pipeName) =>
{
if (!(pipeName is String pipeNameString))
{
throw new ArgumentNullException(nameof(pipeName));
}
_isRunning = true;
while (true)
{
string text;
try
{
PipeSecurity ps = new PipeSecurity();
System.Security.Principal.SecurityIdentifier sid = new System.Security.Principal.SecurityIdentifier(System.Security.Principal.WellKnownSidType.WorldSid, null);
PipeAccessRule par = new PipeAccessRule(sid, PipeAccessRights.ReadWrite, System.Security.AccessControl.AccessControlType.Allow);
//PipeAccessRule psRule = new PipeAccessRule(@"Everyone", PipeAccessRights.ReadWrite, System.Security.AccessControl.AccessControlType.Allow);
ps.AddAccessRule(par);
using (var server = new NamedPipeServerStream(pipeNameString,
PipeDirection.InOut, 1,
PipeTransmissionMode.Message, PipeOptions.None,
4028, 4028, ps))
{
server.WaitForConnection();
using (StreamReader reader = new StreamReader(server))
{
text = reader.ReadToEnd();
}
}
if (text == EXIT_STRING)
{
break;
}
OnReceiveString(text);
}
catch (IOException e)
{
Log.Warn(e);
Thread.Sleep(50);
}
catch (Exception e)
{
Log.Error(e);
Thread.Sleep(50);
}
if (_isRunning == false)
{
break;
}
}
});
Thread.Start(NamedPipeName);
}
public virtual async Task StartListeningAsync(Endpoint Endpoint, CancellationToken Token, Func <Object> GetHandler)
{
var EP = StreamName(Endpoint);
while (true)
{
if (!Token.IsCancellationRequested)
{
try {
var Security = new PipeSecurity();
{
var Everyone = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
var AllowEveryone = new PipeAccessRule(Everyone, PipeAccessRights.FullControl, System.Security.AccessControl.AccessControlType.Allow);
Security.SetAccessRule(AllowEveryone);
}
var C = new NamedPipeServerStream(EP, PipeDirection.InOut, NamedPipeServerStream.MaxAllowedServerInstances, PipeTransmissionMode.Byte, PipeOptions.Asynchronous, 0, 0, Security);
await C.WaitForConnectionAsync(Token)
.DefaultAwait()
;
_ = Task.Run(() => ProcessConnectionAsync(C, GetHandler));
} catch (TaskCanceledException) {
}
}
else
{
break;
}
}
}
private NamedPipeServerStream CreateNewPipeServer()
{
var server = new NamedPipeServerStream(PipeName,
PipeDirection.InOut,
2,
PipeTransmissionMode.Byte,
PipeOptions.Asynchronous,
0,
0,
null,
HandleInheritability.None,
0);
PipeSecurity accessControl = server.GetAccessControl();
// Prevent 'Everyone' account from accessing pipe
var securityIdentifier = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
var rule = new PipeAccessRule(securityIdentifier, PipeAccessRights.Read, AccessControlType.Allow);
accessControl.RemoveAccessRule(rule);
// Prevent 'Anonymous' account from accessing pipe
securityIdentifier = new SecurityIdentifier(WellKnownSidType.AnonymousSid, null);
rule = new PipeAccessRule(securityIdentifier, PipeAccessRights.Read, AccessControlType.Allow);
accessControl.RemoveAccessRule(rule);
return(server);
}
protected override async Task WaitAndProcessAsync(
Func <Stream, CancellationToken, Task> process,
CancellationToken cancellationToken)
{
if (process is null)
{
throw new ArgumentNullException(nameof(process));
}
// https://github.com/PowerShell/PowerShellEditorServices/blob/f45c6312a859cde4aa25ea347a345e1d35238350/src/PowerShellEditorServices.Protocol/MessageProtocol/Channel/NamedPipeServerListener.cs#L38-L67
// Unfortunately, .NET Core does not support passing in a PipeSecurity object into the constructor for
// NamedPipeServerStream so we are creating native Named Pipes and securing them using native APIs.
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
PipeSecurity pipeSecurity = new PipeSecurity();
PipeAccessRule psRule = new PipeAccessRule(@"Everyone", PipeAccessRights.FullControl, System.Security.AccessControl.AccessControlType.Allow);
pipeSecurity.AddAccessRule(psRule);
using (var server = NamedPipeNative.CreateNamedPipe(_options.PipeName, (uint)_options.MaxConcurrentCalls, pipeSecurity))
{
await server.WaitForConnectionAsync(cancellationToken).ConfigureAwait(false);
await process(server, cancellationToken).ConfigureAwait(false);
}
}
// Use original logic on other platforms.
else
{
using (var server = new NamedPipeServerStream(_options.PipeName, PipeDirection.InOut, _options.MaxConcurrentCalls,
PipeTransmissionMode.Byte, PipeOptions.Asynchronous))
{
await server.WaitForConnectionAsync(cancellationToken).ConfigureAwait(false);
await process(server, cancellationToken).ConfigureAwait(false);
}
}
}
public MainWindowViewModel()
{
var stdInPipeName = @"input";
var stdOutPipeName = @"output";
var sid = new SecurityIdentifier(WellKnownSidType.AuthenticatedUserSid, null);
var pipeAccessRule = new PipeAccessRule(sid, PipeAccessRights.ReadWrite, System.Security.AccessControl.AccessControlType.Allow);
var pipeSecurity = new PipeSecurity();
pipeSecurity.AddAccessRule(pipeAccessRule);
var readerPipe = new NamedPipeClientStream(stdInPipeName);
var writerPipe = new NamedPipeClientStream(stdOutPipeName);
readerPipe.Connect();
writerPipe.Connect();
this.languageServer = new LanguageServer.LanguageServer(writerPipe, readerPipe);
this.languageServer.Disconnected += OnDisconnected;
this.languageServer.PropertyChanged += OnLanguageServerPropertyChanged;
Tags.Add(new DiagnosticTag());
this.LogMessage = string.Empty;
this.ResponseText = string.Empty;
}
NamedPipeServerStream CreatePipeAccessControl()
{
// Fix up the DACL on the pipe before opening the listener instance
// This won't disturb the SACL containing the mandatory integrity label
NamedPipeServerStream pipeServer = new NamedPipeServerStream(
PipeName, // The unique pipe name.
PipeDirection, // The pipe is duplex
NamedPipeServerStream.MaxAllowedServerInstances, // MaxAllowedServerInstances
PipeTransmissionMode.Message, // Byte|Message-based communication
PipeOptions.None, // No additional parameters
ReceiveBufferSize, // Input buffer size
SendBufferSize, // Output buffer size
null, // Pipe security attributes
HandleInheritability.None, // Not inheritable
PipeAccessRights.ChangePermissions);
PipeSecurity ps = pipeServer.GetAccessControl();
PipeAccessRule aceClients = new PipeAccessRule(
new SecurityIdentifier(WellKnownSidType.AuthenticatedUserSid, null), // or some other group defining the allowed clients
PipeAccessRights.ReadWrite,
AccessControlType.Allow);
PipeAccessRule aceOwner = new PipeAccessRule(
WindowsIdentity.GetCurrent().Owner,
PipeAccessRights.FullControl,
AccessControlType.Allow);
ps.AddAccessRule(aceClients);
ps.AddAccessRule(aceOwner);
pipeServer.SetAccessControl(ps);
return(pipeServer);
}
private static async void InitializeAppServiceConnection()
{
connection = new NamedPipeServerStream($@"FilesInteropService_ServerPipe", PipeDirection.InOut, NamedPipeServerStream.MaxAllowedServerInstances, PipeTransmissionMode.Message, PipeOptions.Asynchronous, 2048, 2048, null, HandleInheritability.None, PipeAccessRights.ChangePermissions);
PipeSecurity Security = connection.GetAccessControl();
PipeAccessRule ClientRule = new PipeAccessRule(new SecurityIdentifier("S-1-15-2-1"), PipeAccessRights.ReadWrite | PipeAccessRights.CreateNewInstance, AccessControlType.Allow);
PipeAccessRule OwnerRule = new PipeAccessRule(WindowsIdentity.GetCurrent().Owner, PipeAccessRights.FullControl, AccessControlType.Allow);
Security.AddAccessRule(ClientRule);
Security.AddAccessRule(OwnerRule);
if (IsAdministrator())
{
PipeAccessRule EveryoneRule = new PipeAccessRule(new SecurityIdentifier("S-1-1-0"), PipeAccessRights.ReadWrite | PipeAccessRights.CreateNewInstance, AccessControlType.Allow);
Security.AddAccessRule(EveryoneRule); // TODO: find the minimum permission to allow connection when admin
}
connection.SetAccessControl(Security);
await connection.WaitForConnectionAsync();
if (connection.IsConnected)
{
var info = (Buffer : new byte[connection.InBufferSize], Message : new StringBuilder());
BeginRead(info);
}
}
public MainWindowViewModel()
{
Debug.Fail("test");
var stdInPipeName = @"input";
var stdOutPipeName = @"output";
var pipeAccessRule = new PipeAccessRule("Everyone", PipeAccessRights.ReadWrite, System.Security.AccessControl.AccessControlType.Allow);
var pipeSecurity = new PipeSecurity();
pipeSecurity.AddAccessRule(pipeAccessRule);
var readerPipe = new NamedPipeClientStream(stdInPipeName);
var writerPipe = new NamedPipeClientStream(stdOutPipeName);
readerPipe.Connect();
writerPipe.Connect();
this.languageServer = new LanguageServer.LanguageServer(writerPipe, readerPipe);
this.languageServer.Disconnected += OnDisconnected;
this.languageServer.PropertyChanged += OnLanguageServerPropertyChanged;
Tags.Add(new DiagnosticTag());
this.LogMessage = string.Empty;
this.ResponseText = string.Empty;
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
string receivedText;
PipeSecurity ps = new PipeSecurity();
System.Security.Principal.SecurityIdentifier sid = new System.Security.Principal.SecurityIdentifier(System.Security.Principal.WellKnownSidType.WorldSid, null);
PipeAccessRule par = new PipeAccessRule(sid, PipeAccessRights.ReadWrite, System.Security.AccessControl.AccessControlType.Allow);
ps.AddAccessRule(par);
using (var pipeStream = new NamedPipeServerStream(
"test",
PipeDirection.InOut,
1,
PipeTransmissionMode.Message,
PipeOptions.Asynchronous,
4096,
4096,
ps))
{
await pipeStream.WaitForConnectionAsync(stoppingToken);
using (var streamReader = new StreamReader(pipeStream))
{
receivedText = await streamReader.ReadToEndAsync();
}
}
}
/// <summary>
/// Starts a new pipe server and read response from client
/// </summary>
public static string ReceiveNamedPipeServerMessage()
{
try
{
PipeSecurity ps = new PipeSecurity();
PipeAccessRule psRule = new PipeAccessRule(@"Everyone", PipeAccessRights.ReadWrite, System.Security.AccessControl.AccessControlType.Allow);
ps.AddAccessRule(psRule);
using (NamedPipeServerStream namedPipeServer =
new NamedPipeServerStream("test-pipe", PipeDirection.InOut, 1, PipeTransmissionMode.Message, PipeOptions.Asynchronous, 1, 1, ps))
{
namedPipeServer.WaitForConnection();
IFormatter f = new BinaryFormatter();
var namedPipePayload = (NamedPipePayload)f.Deserialize(namedPipeServer);
return(namedPipePayload.SignalQuit ? null : namedPipePayload.Arguments);
}
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}");
}
return(null);
}
protected bool AreAccessRulesEqual(PipeAccessRule expectedRule, PipeAccessRule actualRule)
{
return
(expectedRule.AccessControlType == actualRule.AccessControlType &&
expectedRule.PipeAccessRights == actualRule.PipeAccessRights &&
expectedRule.InheritanceFlags == actualRule.InheritanceFlags &&
expectedRule.PropagationFlags == actualRule.PropagationFlags);
}
protected PipeSecurity GetPipeSecurity(WellKnownSidType sid, PipeAccessRights rights, AccessControlType accessControl)
{
var security = new PipeSecurity();
SecurityIdentifier identity = new SecurityIdentifier(sid, null);
var accessRule = new PipeAccessRule(identity, rights, accessControl);
security.AddAccessRule(accessRule);
return(security);
}
////////////////////////////////////////////////////////////////////////////////
//
////////////////////////////////////////////////////////////////////////////////
internal SMBServer(String pipeName)
{
SecurityIdentifier sid = new SecurityIdentifier(WellKnownSidType.AuthenticatedUserSid, null);
PipeAccessRule access = new PipeAccessRule(sid, PipeAccessRights.ReadWrite, AccessControlType.Allow);
PipeSecurity pipeSecurity = new PipeSecurity();
pipeSecurity.AddAccessRule(access);
namedPipeServerStream = new NamedPipeServerStream(pipeName, PipeDirection.InOut, 100, PipeTransmissionMode.Byte, PipeOptions.None, 0, 0, pipeSecurity);
}
private void PipeThreadStart()
{
PipeSecurity pSec = new PipeSecurity();
PipeAccessRule pAccRule = new PipeAccessRule(new SecurityIdentifier(WellKnownSidType.BuiltinUsersSid, null)
, PipeAccessRights.ReadWrite | PipeAccessRights.Synchronize, System.Security.AccessControl.AccessControlType.Allow);
pSec.AddAccessRule(pAccRule);
using (_pipeServer = new NamedPipeServerStream("NKT_SQLINTERCEPT_PIPE",
PipeDirection.InOut,
NamedPipeServerStream.MaxAllowedServerInstances,
PipeTransmissionMode.Byte,
PipeOptions.None,
MAX_STRING_CCH * 2,
MAX_STRING_CCH * 2,
pSec,
HandleInheritability.Inheritable))
{
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine("(pipe thread) Waiting for connection...");
Console.ForegroundColor = ConsoleColor.Gray;
try
{
_pipeServer.WaitForConnection();
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine("(pipe thread) Client connected.");
Console.ForegroundColor = ConsoleColor.Gray;
while (true)
{
byte[] readBuf = new byte[MAX_STRING_CCH * 2];
int cbRead = _pipeServer.Read(readBuf, 0, MAX_STRING_CCH * 2);
string str = Encoding.Unicode.GetString(readBuf, 0, cbRead);
Console.WriteLine(str);
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("--------------------------------------------------------");
Console.ForegroundColor = ConsoleColor.Gray;
if (_blockQuery)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("(pipe thread) QUERY ABORTED");
Console.ForegroundColor = ConsoleColor.Gray;
}
}
}
catch (System.Exception ex)
{
Console.WriteLine("(pipethread) Pipe or data marshaling operation exception! ({0})", ex.Message);
}
}
}
public void SetDefaultSecurity()
{
PipeSecurity pipeSecurity = new PipeSecurity();
SecurityIdentifier everyoneSID = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
PipeAccessRule accessRule = new PipeAccessRule(everyoneSID, PipeAccessRights.ReadWrite, AccessControlType.Allow);
pipeSecurity.AddAccessRule(accessRule);
this.server.SetSecurity(pipeSecurity);
}
public NamedPipeServerStream CreatePipe(string name, int maxInstances = NamedPipeServerStream.MaxAllowedServerInstances)
{
PipeSecurity ps = new PipeSecurity();
SecurityIdentifier sid = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
PipeAccessRule par = new PipeAccessRule(sid, PipeAccessRights.ReadWrite, System.Security.AccessControl.AccessControlType.Allow);
ps.AddAccessRule(par);
return(new NamedPipeServerStream(name, PipeDirection.InOut, maxInstances, PipeTransmissionMode.Byte, PipeOptions.Asynchronous, 1024, 1024, ps));
}
/// <summary>
/// Instantiates an endpoint to act as a client
/// </summary>
/// <param name="pipeName">The name of the pipe to which we should connect.</param>
internal void InternalConstruct(string pipeName)
{
ErrorUtilities.VerifyThrowArgumentLength(pipeName, nameof(pipeName));
_debugCommunications = (Environment.GetEnvironmentVariable("MSBUILDDEBUGCOMM") == "1");
_status = LinkStatus.Inactive;
_asyncDataMonitor = new object();
_sharedReadBuffer = InterningBinaryReader.CreateSharedBuffer();
_packetStream = new MemoryStream();
_binaryWriter = new BinaryWriter(_packetStream);
#if FEATURE_PIPE_SECURITY && FEATURE_NAMED_PIPE_SECURITY_CONSTRUCTOR
if (!NativeMethodsShared.IsMono)
{
SecurityIdentifier identifier = WindowsIdentity.GetCurrent().Owner;
PipeSecurity security = new PipeSecurity();
// Restrict access to just this account. We set the owner specifically here, and on the
// pipe client side they will check the owner against this one - they must have identical
// SIDs or the client will reject this server. This is used to avoid attacks where a
// hacked server creates a less restricted pipe in an attempt to lure us into using it and
// then sending build requests to the real pipe client (which is the MSBuild Build Manager.)
PipeAccessRule rule = new PipeAccessRule(identifier, PipeAccessRights.ReadWrite, AccessControlType.Allow);
security.AddAccessRule(rule);
security.SetOwner(identifier);
_pipeServer = new NamedPipeServerStream
(
pipeName,
PipeDirection.InOut,
1, // Only allow one connection at a time.
PipeTransmissionMode.Byte,
PipeOptions.Asynchronous | PipeOptions.WriteThrough,
PipeBufferSize, // Default input buffer
PipeBufferSize, // Default output buffer
security,
HandleInheritability.None
);
}
else
#endif
{
_pipeServer = new NamedPipeServerStream
(
pipeName,
PipeDirection.InOut,
1, // Only allow one connection at a time.
PipeTransmissionMode.Byte,
PipeOptions.Asynchronous | PipeOptions.WriteThrough,
PipeBufferSize, // Default input buffer
PipeBufferSize // Default output buffer
);
}
}
public static NamedPipeServerStream CreatePipe(string p_PipeName)
{
var s_Security = new PipeSecurity();
var s_Identifier = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
var s_AccessRule = new PipeAccessRule(s_Identifier, PipeAccessRights.ReadWrite, System.Security.AccessControl.AccessControlType.Allow);
s_Security.AddAccessRule(s_AccessRule);
return(new NamedPipeServerStream(p_PipeName, PipeDirection.InOut, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous | PipeOptions.WriteThrough, 1024, 1024, s_Security));
}
public NamedPipeManager()
{
SecurityIdentifier sid = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
PipeAccessRule psRule = new PipeAccessRule(sid, PipeAccessRights.ReadWrite, AccessControlType.Allow);
pipeSecurity = new PipeSecurity();
pipeSecurity.AddAccessRule(psRule);
NamedPipeStream_Server = new NamedPipeServerStream(Name, PipeDirection.InOut, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous, 512, 512, pipeSecurity);
}
/// <summary>
/// Creates a security profile for the pipes (Was used in .NET Framework.. No longer needed in Core 3? (Crashes))
/// </summary>
private static PipeSecurity CreateSystemIoPipeSecurity()
{
PipeSecurity pipe_security = new PipeSecurity();
PipeAccessRule access_rule = new PipeAccessRule("Everyone", PipeAccessRights.ReadWrite, AccessControlType.Allow);
pipe_security.AddAccessRule(access_rule);
PipeAccessRule access_rule2 = new PipeAccessRule("Everyone", PipeAccessRights.FullControl, AccessControlType.Allow);
pipe_security.AddAccessRule(access_rule2);
return(pipe_security);
}
private void StartNamedPipeServer()
{
if (!StartServer)
{
return;
}
#if NETCOREAPP2_1 || NETCOREAPP3_1 || NET5_0
if (!System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(System.Runtime.InteropServices.OSPlatform.Windows))
{
throw new PlatformNotSupportedException("The communication with the first instance is only supported on Windows");
}
_server = new NamedPipeServerStream(
PipeName,
PipeDirection.In,
NamedPipeServerStream.MaxAllowedServerInstances,
PipeTransmissionMode.Message,
PipeOptions.CurrentUserOnly);
#elif NET461
using (var currentIdentity = WindowsIdentity.GetCurrent())
{
var identifier = currentIdentity.Owner;
// Grant full control to the owner so multiple servers can be opened.
// Full control is the default per MSDN docs for CreateNamedPipe.
var rule = new PipeAccessRule(identifier, PipeAccessRights.FullControl, AccessControlType.Allow);
var pipeSecurity = new PipeSecurity();
pipeSecurity.AddAccessRule(rule);
pipeSecurity.SetOwner(identifier);
_server = new NamedPipeServerStream(
PipeName,
PipeDirection.In,
NamedPipeServerStream.MaxAllowedServerInstances,
PipeTransmissionMode.Message,
PipeOptions.Asynchronous,
0,
0,
pipeSecurity);
}
#else
#error Platform not supported
#endif
try
{
_server.BeginWaitForConnection(Listen, state: null !); // TODO-NULLABLE https://github.com/dotnet/runtime/pull/42442
}
catch (ObjectDisposedException)
{
// The server was disposed before getting a connection
}
}
public NamedPipeProcessInteropServer(string pipeName)
{
_pipeName = pipeName;
var _pipeSecurity = new PipeSecurity();
var psEveryone = new PipeAccessRule("Everyone", PipeAccessRights.FullControl, System.Security.AccessControl.AccessControlType.Allow);
_pipeSecurity.AddAccessRule(psEveryone);
_pipe = new NamedPipeServerStream(_pipeName, PipeDirection.InOut, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous, 100, 100, _pipeSecurity);
stream = _pipe;
_timer.Elapsed += _timer_Elapsed;
}
//private static bool exit = false;
public static void CreateNamedPipeServer(string pipeName)
{
PipeSecurity pipeSecurityDescriptor = new PipeSecurity();
PipeAccessRule everyoneAllowedRule = new PipeAccessRule("Everyone", PipeAccessRights.ReadWrite, AccessControlType.Allow);
PipeAccessRule networkDenyRule = new PipeAccessRule("Network", PipeAccessRights.ReadWrite, AccessControlType.Deny); // This should only be used locally, so lets limit the scope
pipeSecurityDescriptor.AddAccessRule(everyoneAllowedRule);
//pipeSecurityDescriptor.AddAccessRule(networkDenyRule);
// Gotta be careful with the buffer sizes. There's a max limit on how much data you can write to a pipe in one sweep. IIRC it's ~55,000, but I dunno for sure.
pipeServer = new NamedPipeServerStream(pipeName, PipeDirection.InOut, 10, PipeTransmissionMode.Message, PipeOptions.Asynchronous, 32768, 32768, pipeSecurityDescriptor);
}