private static void bindingSetAuthInfo(RPC_C_AUTHN_LEVEL level, RPC_C_AUTHN[] authTypes, RpcHandle handle, string serverPrincipalName, NetworkCredential credentails) { if (credentails == null) { foreach (RPC_C_AUTHN atype in authTypes) { RPC_STATUS result = NativeMethods.RpcBindingSetAuthInfo2(handle.Handle, serverPrincipalName, level, atype, IntPtr.Zero, 0); if (result != RPC_STATUS.RPC_S_OK) { RpcTrace.Warning("Unable to register {0}, result = {1}", atype, new RpcException(result).Message); } } } else { SEC_WINNT_AUTH_IDENTITY pSecInfo = new SEC_WINNT_AUTH_IDENTITY(credentails); foreach (RPC_C_AUTHN atype in authTypes) { RPC_STATUS result = NativeMethods.RpcBindingSetAuthInfo(handle.Handle, serverPrincipalName, level, atype, ref pSecInfo, 0); if (result != RPC_STATUS.RPC_S_OK) { RpcTrace.Warning("Unable to register {0}, result = {1}", atype, new RpcException(result).Message); } } } }
private static void bindingFromStringBinding(RpcHandle handle, String bindingString) { RPC_STATUS result = NativeMethods.RpcBindingFromStringBinding(bindingString, out handle.Handle); Guard.Assert(result); RpcTrace.Verbose("RpcClient.bindingFromStringBinding({0} = {1})", handle.Handle, bindingString); }
public static void Assert(RPC_STATUS errorsCode) { if (errorsCode != RPC_STATUS.RPC_S_OK) { RpcException ex = new RpcException(errorsCode); RpcTrace.Error("RPC_STATUS.{0} - {1}", errorsCode, ex.Message); throw ex; } }
private RPC_STATUS CheckRPCStatus() { RPC_STATUS status = ReceiveRPCStatus(); if (IsFatalStatus(status)) { StatusMessages.TryGetValue(status, out string value); throw new Exception($"librpc: {value}"); } return(status); }
private static bool serverRegisterAuthInfo(RPC_C_AUTHN auth, string serverPrincName) { RpcTrace.Verbose("serverRegisterAuthInfo({0})", auth); RPC_STATUS response = NativeMethods.RpcServerRegisterAuthInfo(serverPrincName, (uint)auth, IntPtr.Zero, IntPtr.Zero); if (response != RPC_STATUS.RPC_S_OK) { RpcTrace.Warning("serverRegisterAuthInfo - unable to register authentication type {0}", auth); return(false); } return(true); }
private static void serverListen(int maxCalls) { RpcTrace.Verbose("Begin Server Listening"); // starts listening all server in process on registered protocols //TODO: make server isolated of other process services, make it not static as possible RPC_STATUS result = NativeMethods.RpcServerListen(1, maxCalls, 1); if (result == RPC_STATUS.RPC_S_ALREADY_LISTENING) { result = RPC_STATUS.RPC_S_OK; } Guard.Assert(result); RpcTrace.Verbose("Server Ready"); }
private static bool serverUseProtseqEp(RpcProtseq protocol, int maxCalls, String endpoint) { RpcTrace.Verbose("serverUseProtseqEp({0})", protocol); // all RPC servers within the process will be available on that protocol // once invoked this can not be undone //TODO: make server isolated of other process services, make it not static as possible RPC_STATUS err = NativeMethods.RpcServerUseProtseqEp(protocol.ToString(), maxCalls, endpoint, IntPtr.Zero); if (err != RPC_STATUS.RPC_S_DUPLICATE_ENDPOINT) { Guard.Assert(err); } return(err == RPC_STATUS.RPC_S_OK); }
// Creates a string binding handle. // This function is nothing more than a printf. // Connection is not done here. private static String stringBindingCompose(EndpointBindingInfo endpointBindingInfo, String Options) { IntPtr lpBindingString; RPC_STATUS result = NativeMethods.RpcStringBindingCompose(null, endpointBindingInfo.Protseq.ToString(), endpointBindingInfo.NetworkAddr, endpointBindingInfo.EndPoint, Options, out lpBindingString); Guard.Assert(result); try { return(Marshal.PtrToStringUni(lpBindingString)); } finally { Guard.Assert(NativeMethods.RpcStringFree(ref lpBindingString)); } }
private static void serverStopListening() { RpcTrace.Verbose("Stop Server Listening"); // stops listening on all registered protocols. //TODO: make server isolated of other process services, make it not static as possible RPC_STATUS result = NativeMethods.RpcMgmtStopServerListening(IntPtr.Zero); if (result != RPC_STATUS.RPC_S_OK) { RpcTrace.Warning("RpcMgmtStopServerListening result = {0}", result); } //TODO: make server isolated of other process services, make it not static as possible result = NativeMethods.RpcMgmtWaitServerListen(); if (result != RPC_STATUS.RPC_S_OK) { RpcTrace.Warning("RpcMgmtWaitServerListen result = {0}", result); } }
/// <summary> /// Get process information (memory map) /// </summary> /// <param name="pid">Process ID</param> /// <returns></returns> public ProcessInfo GetProcessInfo(int pid) { if (!IsConnected) { throw new Exception(NotConnectedErrorMessage); } SendCMDPacket(RPC_CMDS.RPC_PROC_INFO, RPC_PROC_INFO1_SIZE); SendPacketData(RPC_PROC_INFO1_SIZE, pid); RPC_STATUS status = CheckRPCStatus(); if (status == RPC_STATUS.RPC_INFO_NO_MAP) { return(new ProcessInfo(pid, null)); } // recv count byte[] bnumber = new byte[4]; sock.Receive(bnumber, 4, SocketFlags.None); int number = BitConverter.ToInt32(bnumber, 0); // recv data byte[] data = ReceiveData(number * RPC_PROC_INFO2_SIZE); // parse data MemoryEntry[] entries = new MemoryEntry[number]; for (int i = 0; i < number; i++) { int offset = i * RPC_PROC_INFO2_SIZE; entries[i] = new MemoryEntry { name = GetNullTermString(data, offset), start = BitConverter.ToUInt64(data, offset + 32), end = BitConverter.ToUInt64(data, offset + 40), offset = BitConverter.ToUInt64(data, offset + 48), prot = BitConverter.ToUInt32(data, offset + 56) }; } return(new ProcessInfo(pid, entries)); }
private static bool IsFatalStatus(RPC_STATUS status) { // if status first nibble starts with F return((uint)status >> 28 == 15); }
/// <summary> /// Exception class: RpcException : System.ComponentModel.Win32Exception /// Unspecified rpc error /// </summary> public RpcException(RPC_STATUS errorsCode) : base(unchecked((int)errorsCode)) { }
/// <summary> /// Exception class: RpcException : System.ComponentModel.Win32Exception /// Unspecified rpc error /// </summary> public RpcException(RPC_STATUS errorsCode) : base(unchecked ((int)errorsCode)) { }
private RPC_CALL_ATTRIBUTES_V2 GetCallInfo() { if (_callAttrs.Version != 0) { return(_callAttrs); } var attrs = new RPC_CALL_ATTRIBUTES_V2 { Version = 2, Flags = RPC_CALL_ATTRIBUTES_FLAGS.RPC_QUERY_NO_AUTH_REQUIRED }; RPC_STATUS err = NativeMethods.RpcServerInqCallAttributes(_clientHandle, ref attrs); if (err == RPC_STATUS.RPC_S_INVALID_ARG) //may not support v2 on early edditions of XP/SP3 { attrs.Version = 1; err = NativeMethods.RpcServerInqCallAttributes(_clientHandle, ref attrs); } if (err == RPC_STATUS.RPC_S_OK) { _callAttrs = attrs; _isAuthenticated = false; attrs.Flags = RPC_CALL_ATTRIBUTES_FLAGS.RPC_QUERY_IS_CLIENT_LOCAL | RPC_CALL_ATTRIBUTES_FLAGS.RPC_QUERY_NO_AUTH_REQUIRED; if ((err = NativeMethods.RpcServerInqCallAttributes(_clientHandle, ref attrs)) == RPC_STATUS.RPC_S_OK) { _callAttrs.IsClientLocal = attrs.IsClientLocal; if (_callAttrs.ProtocolSequence == RpcProtoseqType.LRPC) { attrs.Flags = RPC_CALL_ATTRIBUTES_FLAGS.RPC_QUERY_CLIENT_PID; if ((err = NativeMethods.RpcServerInqCallAttributes(_clientHandle, ref attrs)) == RPC_STATUS.RPC_S_OK) { _callAttrs.ClientPID = attrs.ClientPID; } } } if (_callAttrs.ProtocolSequence != RpcProtoseqType.LRPC) { using (Ptr <byte[]> callerAddress = new Ptr <byte[]>(new byte[1024])) { var localAddress = new RPC_CALL_LOCAL_ADDRESS_V1(); localAddress.Version = 1; localAddress.Buffer = callerAddress.Handle; localAddress.BufferSize = 1024; localAddress.AddressFormat = RpcLocalAddressFormat.Invalid; _callAttrs = attrs; using (var callerAddressv1 = new Ptr <RPC_CALL_LOCAL_ADDRESS_V1>(localAddress)) { attrs.CallLocalAddress = callerAddressv1.Handle; attrs.Flags = RPC_CALL_ATTRIBUTES_FLAGS.RPC_QUERY_CALL_LOCAL_ADDRESS | RPC_CALL_ATTRIBUTES_FLAGS.RPC_QUERY_NO_AUTH_REQUIRED; if ((err = NativeMethods.RpcServerInqCallAttributes(_clientHandle, ref attrs)) == RPC_STATUS.RPC_S_OK) { _clientAddress = new byte[callerAddressv1.Data.BufferSize]; Array.Copy(callerAddress.Data, _clientAddress, _clientAddress.Length); } } } } using (Ptr <byte[]> clientPrincipal = new Ptr <byte[]>(new byte[1024])) { attrs.ClientPrincipalName = clientPrincipal.Handle; attrs.ClientPrincipalNameBufferLength = 1024; attrs.Flags = RPC_CALL_ATTRIBUTES_FLAGS.RPC_QUERY_CLIENT_PRINCIPAL_NAME; if ((err = NativeMethods.RpcServerInqCallAttributes(_clientHandle, ref attrs)) == RPC_STATUS.RPC_S_OK) { _clientPrincipalName = Marshal.PtrToStringUni(clientPrincipal.Handle); if (!String.IsNullOrEmpty(_clientPrincipalName)) { _isAuthenticated = true; //On Windows XP this only returns a value on LRPC so we know they are local if (attrs.Version == 1) { _callAttrs.IsClientLocal = RpcCallClientLocality.Local; } } } } } else { RpcTrace.Warning("RpcServerInqCallAttributes error {0} = {1}", err, new RpcException(err).Message); } return(_callAttrs); }