/// <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);
}
