/// <summary> /// Creates a BindResponse for normal bindings, SASL bindings and sicily bindings. /// </summary> /// <param name="context">The user context which contains message ID.</param> /// <param name="resultCode">Result code of previous request, as specified in RFC 2251.</param> /// <param name="matchedDn">Matched DN. Required, but can be an empty string.</param> /// <param name="errorMessage">Error message for result code. Required.</param> /// <param name="referral">Referral. Optional and for LDAP v3 only.</param> /// <param name="serverCredentials">Server credentials, optional for normal bind.</param> /// <returns>The packet that contains the response.</returns> internal override AdtsBindResponsePacket CreateBindResponse( AdtsLdapContext context, MsLdap.ResultCode resultCode, string matchedDn, string errorMessage, string[] referral, byte[] serverCredentials) { BindResponse bindResponse = new BindResponse( new LDAPResult_resultCode((long)resultCode), new LDAPDN(matchedDn ?? string.Empty), new LDAPString(errorMessage ?? string.Empty)); LDAPMessage_protocolOp operation = new LDAPMessage_protocolOp(); operation.SetData(LDAPMessage_protocolOp.bindResponse, bindResponse); LDAPMessage message = new LDAPMessage(new MessageID(context.MessageId), operation); AdtsBindResponsePacket packet = new AdtsBindResponsePacket(); packet.ldapMessagev2 = message; packet.messageId = context.MessageId; return(packet); }
public void When_Serialize_BindResponse_With_Error() { var operation = new BindResponse(); operation.Result = new LDAPResult { MatchedDN = new DEROctetString("administrator"), DiagnosticMessage = new DEROctetString("error"), ResultCode = new DEREnumerated <LDAPResultCodes> { Value = LDAPResultCodes.AuthMethodNotSupported } }; var ldapPacket = new LdapPacket { MessageId = new DERInteger(1), ProtocolOperation = new DERProtocolOperation { Operation = operation } }; var payload = ldapPacket.Serialize(); var deserializedLdapPacket = LdapPacket.Extract(payload); var ldapResult = operation.Result as LDAPResult; Assert.NotNull(deserializedLdapPacket); Assert.Equal("administrator", ldapResult.MatchedDN.Value); Assert.Equal("error", ldapResult.DiagnosticMessage.Value); Assert.Equal(LDAPResultCodes.AuthMethodNotSupported, ldapResult.ResultCode.Value); }
async Task <HandlerReply> IRequestHandler <BindRequest> .Handle(ClientContext context, LdapEvents eventListener, BindRequest operation) { Dictionary <string, List <string> > rdn = RdnParser.ParseRdnString(operation.Name); AuthenticationEvent authEvent = new AuthenticationEvent(rdn, operation.Authentication); bool success = await eventListener.OnAuthenticationRequest(context, authEvent); if (success) { context.IsAuthenticated = true; context.Rdn = rdn; LdapResult ldapResult = new LdapResult(LdapResult.ResultCodeEnum.Success, null, null); BindResponse bindResponse = new BindResponse(ldapResult); return(new HandlerReply(new List <IProtocolOp> { bindResponse })); } else { context.IsAuthenticated = false; context.Rdn = new Dictionary <string, List <string> >(); LdapResult ldapResult = new LdapResult(LdapResult.ResultCodeEnum.InappropriateAuthentication, null, null); BindResponse bindResponse = new BindResponse(ldapResult); return(new HandlerReply(new List <IProtocolOp> { bindResponse })); } }
public static void OnBindRequest(Client pClient, Header pHeader, MemoryStream pData) { BindRequest bindRequest = new BindRequest(); if (!bindRequest.Read(pData)) { return; } BindResponse bindResponse = new BindResponse(); foreach (uint hash in bindRequest.ImportedServiceHashes) { uint serviceId = 0; if (Program.GetClientServiceId(hash, out serviceId) && !pClient.ImportedServices.Contains(serviceId)) { if (pClient.PermittedServices.Contains(serviceId)) { pClient.Log(ELogLevel.Debug, "Importing Service {0}", serviceId); pClient.ImportedServices.Add(serviceId); bindResponse.ImportedServiceIds.Add(serviceId); } else { pClient.RequestedServices.Add(new Tuple <uint, uint>(serviceId, pHeader.Token)); } } } if (bindResponse.HasImportedServiceIds) { MemoryStream response = new MemoryStream(128); bindResponse.Write(response); pClient.SendResponse(pHeader.Token, 0, 0, null, response); } }
public override void Bind(Google.ProtocolBuffers.IRpcController controller, BindRequest request, Action <BindResponse> done) { var requestedServiceIDs = new List <uint>(); foreach (var serviceHash in request.ImportedServiceHashList) { var serviceID = Service.GetByHash(serviceHash); Logger.Trace("Bind() [export] Hash: 0x{0} ID: 0x{1} Service: {2} ", serviceHash.ToString("X8"), serviceID.ToString("X2"), Service.GetByID(serviceID) != null ? Service.GetByID(serviceID).GetType().Name : "N/A"); requestedServiceIDs.Add(serviceID); } // read services supplied by client.. foreach (var service in request.ExportedServiceList.Where(service => !Client.Services.ContainsValue(service.Id))) { if (Client.Services.ContainsKey(service.Hash)) { continue; } Client.Services.Add(service.Hash, service.Id); Logger.Trace(string.Format("Bind() [import] Hash: 0x{0} ID: 0x{1}", service.Hash.ToString("X8"), service.Id.ToString("X2"))); } var builder = BindResponse.CreateBuilder(); foreach (var serviceId in requestedServiceIDs) { builder.AddImportedServiceId(serviceId); } done(builder.Build()); }
private void PrintBindServiceResponse(BindResponse response) { string text = "BindResponse: { "; int importedServiceIdCount = response.ImportedServiceIdCount; text = text + "Num Imported Services: " + importedServiceIdCount; text += " ["; for (int i = 0; i < importedServiceIdCount; i++) { text = text + " Id:" + response.ImportedServiceId[i]; } text += " ]"; text += " }"; this.m_logSource.LogDebug(text); }
private static LdapPacket BuildError(LdapPacket request, LdapException ex) { BaseOperationDone operation = null; switch (request.ProtocolOperation.Tag.LdapCommand) { case LdapCommands.AddRequest: operation = new AddResponse(); break; case LdapCommands.BindRequest: operation = new BindResponse(); break; case LdapCommands.DelRequest: operation = new DelResponse(); break; case LdapCommands.SearchRequest: operation = new SearchResultDone(); break; case LdapCommands.ModifyRequest: operation = new ModifyResponse(); break; } operation.Result = new LDAPResult { MatchedDN = new DEROctetString(ex.Target), DiagnosticMessage = new DEROctetString(ex.Message), ResultCode = new DEREnumerated <LDAPResultCodes> { Value = ex.Code } }; var ldapPacket = new LdapPacket { MessageId = request.MessageId, ProtocolOperation = new DERProtocolOperation { Operation = operation } }; return(ldapPacket); }
public override void Bind(IRpcController controller, BindRequest request, Action <BindResponse> done) { var newResponse = BindResponse.CreateBuilder(); foreach (var hash in request.ImportedServiceHashList) { newResponse.AddImportedServiceId(client.LoadImportedService(hash)); } foreach (var s in request.ExportedServiceList) { client.LoadExportedService(s.Hash, s.Id); } var response = newResponse.Build(); done(response); }
public override void Bind(IRpcController controller, BindRequest request, Action <BindResponse> done) { var response = BindResponse.CreateBuilder(); // export all services requested by the client and add their id to the response foreach (var import in request.ImportedServiceHashList) { var index = client.ExportService(import); response.AddImportedServiceId(index); } // store which services the client exports to us foreach (var export in request.ExportedServiceList) { client.ImportService(export.Hash, export.Id); } done(response.Build()); }
async Task <HandlerReply> IRequestHandler <ExtendedRequest> .Handle(ClientContext context, LdapEvents eventListener, ExtendedRequest operation) { if (operation.RequestName == StartTLS && SingletonContainer.GetCertificate() != null) { context.HasEncryptedConnection = true; return(new HandlerReply(new List <IProtocolOp> { new ExtendedOperationResponse( new LdapResult(LdapResult.ResultCodeEnum.Success, null, null), StartTLS, null ), })); } LdapResult ldapResult = new LdapResult(LdapResult.ResultCodeEnum.ProtocolError, null, null); BindResponse bindResponse = new BindResponse(ldapResult); return(new HandlerReply(new List <IProtocolOp> { bindResponse })); }
private void BindSession(SessionBindInfo bindInfo, int timeOut) { _vTcpIpSession.SessionClosed += TcpIpSessionClosedEventHandler; BindRequest bindReq = bindInfo.CreatePdu(); _vTrans.Send(bindReq); BindResponse bindResp = null; try { bindResp = (BindResponse)_vRespHandler.WaitResponse(bindReq, timeOut); } catch (SmppResponseTimedOutException ex) { throw new SmppBindException(ex); } if (bindResp.Header.ErrorCode != 0) { throw new SmppBindException(bindResp.Header.ErrorCode); } //Copy settings _vSmscId = bindResp.SystemId; _vSystemId = bindInfo.SystemId; _vPassword = bindInfo.Password; _vAddressTon = bindInfo.AddressTon; _vAddressNpi = bindInfo.AddressNpi; //Start timer _vTimer.Start(); _vIsAlive = true; switch (bindReq.Header.CommandType) { case CommandType.BindTransceiver: ChangeState(SmppSessionState.Transceiver); break; case CommandType.BindReceiver: ChangeState(SmppSessionState.Receiver); break; case CommandType.BindTransmitter: ChangeState(SmppSessionState.Transmitter); break; } }
public override void CallServerMethod(uint token, uint methodId, CodedInputStream stream) { switch (methodId) { case 1: { ConnectRequest request = ConnectRequest.Parser.ParseFrom(stream); ConnectResponse response = new ConnectResponse(); BattlenetRpcErrorCode status = HandleConnect(request, response); Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method ConnectionService.Connect(bgs.protocol.connection.v1.ConnectRequest: {1}) returned bgs.protocol.connection.v1.ConnectResponse: {2} status: {3}.", GetCallerInfo(), request.ToString(), response.ToString(), status); if (status == 0) { SendResponse(token, response); } else { SendResponse(token, status); } break; } case 2: { BindRequest request = new BindRequest(); request.MergeFrom(stream); BindResponse response = new BindResponse(); BattlenetRpcErrorCode status = HandleBind(request, response); Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method ConnectionService.Bind(bgs.protocol.connection.v1.BindRequest: {1}) returned bgs.protocol.connection.v1.BindResponse: {2} status: {3}.", GetCallerInfo(), request.ToString(), response.ToString(), status); if (status == 0) { SendResponse(token, response); } else { SendResponse(token, status); } break; } case 3: { EchoRequest request = new EchoRequest(); request.MergeFrom(stream); EchoResponse response = new EchoResponse(); BattlenetRpcErrorCode status = HandleEcho(request, response); Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method ConnectionService.Echo(bgs.protocol.connection.v1.EchoRequest: {1}) returned bgs.protocol.connection.v1.EchoResponse: {2} status: {3}.", GetCallerInfo(), request.ToString(), response.ToString(), status); if (status == 0) { SendResponse(token, response); } else { SendResponse(token, status); } break; } case 4: { DisconnectNotification request = DisconnectNotification.Parser.ParseFrom(stream); BattlenetRpcErrorCode status = HandleForceDisconnect(request); Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method ConnectionService.ForceDisconnect(bgs.protocol.connection.v1.DisconnectNotification: {1}) status: {2}.", GetCallerInfo(), request.ToString(), status); if (status != 0) { SendResponse(token, status); } break; } case 5: { NoData request = NoData.Parser.ParseFrom(stream); BattlenetRpcErrorCode status = HandleKeepAlive(request); Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method ConnectionService.KeepAlive(bgs.protocol.NoData: {1}) status: {2}.", GetCallerInfo(), request.ToString(), status); if (status != 0) { SendResponse(token, status); } break; } case 6: { EncryptRequest request = EncryptRequest.Parser.ParseFrom(stream); NoData response = new NoData(); BattlenetRpcErrorCode status = HandleEncrypt(request, response); Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method ConnectionService.Encrypt(bgs.protocol.connection.v1.EncryptRequest: {1}) returned bgs.protocol.NoData: {2} status: {3}.", GetCallerInfo(), request.ToString(), response.ToString(), status); if (status == 0) { SendResponse(token, response); } else { SendResponse(token, status); } break; } case 7: { DisconnectRequest request = DisconnectRequest.Parser.ParseFrom(stream); BattlenetRpcErrorCode status = HandleRequestDisconnect(request); Log.outDebug(LogFilter.ServiceProtobuf, "{0} Client called server method ConnectionService.RequestDisconnect(bgs.protocol.connection.v1.DisconnectRequest: {1}) status: {2}.", GetCallerInfo(), request.ToString(), status); if (status != 0) { SendResponse(token, status); } break; } default: Log.outError(LogFilter.ServiceProtobuf, "Bad method id {0}.", methodId); SendResponse(token, BattlenetRpcErrorCode.RpcInvalidMethod); break; } }
BattlenetRpcErrorCode HandleBind(BindRequest request, BindResponse response) { Log.outError(LogFilter.ServiceProtobuf, "{0} Client tried to call not implemented method ConnectionService.Bind: {1}", GetCallerInfo(), request.ToString()); return(BattlenetRpcErrorCode.RpcNotImplemented); }
public static DERProtocolOperation Extract(ICollection <byte> buffer) { var result = new DERProtocolOperation(); result.ExtractTagAndLength(buffer); switch (result.Tag.LdapCommand) { case LdapCommands.SearchRequest: result.Operation = SearchRequest.Extract(buffer); break; case LdapCommands.BindRequest: result.Operation = BindRequest.Extract(buffer); break; case LdapCommands.UnbindRequest: result.Operation = UnbindRequest.Extract(buffer); break; case LdapCommands.AddRequest: result.Operation = AddRequest.Extract(buffer); break; case LdapCommands.DelRequest: result.Operation = DelRequest.Extract(buffer, result.Length); break; case LdapCommands.ModifyDNRequest: result.Operation = ModifyDNRequest.Extract(buffer); break; case LdapCommands.CompareRequest: result.Operation = CompareRequest.Extract(buffer); break; case LdapCommands.AbandonRequest: result.Operation = AbandonRequest.Extract(buffer); break; case LdapCommands.ModifyRequest: result.Operation = ModifyRequest.Extract(buffer); break; case LdapCommands.SearchResultDone: result.Operation = SearchResultDone.Extract(buffer); break; case LdapCommands.BindResponse: result.Operation = BindResponse.Extract(buffer); break; case LdapCommands.AddResponse: result.Operation = AddResponse.Extract(buffer); break; case LdapCommands.SearchResultEntry: result.Operation = SearchResultEntry.Extract(buffer); break; } return(result); }