public override DecodeTokenResponse Query(DecodeTokenRequest request, IServiceRouter router, RequestContext context)
{
DecodeTokenResponse response = new DecodeTokenResponse();
DecryptResponse decrypt = router.Query <DecryptRequest, DecryptResponse>(new DecryptRequest()
{
Key = request.Key,
CipherText = request.Data,
IV = request.IV,
Algorithm = request.Algorithm
});
string tokenStr = Encoding.ASCII.GetString(decrypt.ClearText);
Dictionary <string, string> parts = tokenStr.Split('|').Select(x => x.Split(new[] { ':' }, 1)).ToDictionary(x => x[0], x => x[1]);
Token token = new Token()
{
Type = (TokenType)Enum.Parse(typeof(TokenType), parts["type"], true),
PrincipalId = Guid.Parse(parts["prin"]),
Data = Convert.ToBase64String(request.Data),
Expiration = DateTime.ParseExact(parts["expire"], "yyyyMMddHHmmss", CultureInfo.CurrentCulture),
Issued = DateTime.ParseExact(parts["issued"], "yyyyMMddHHmmss", CultureInfo.CurrentCulture)
};
response.Token = token;
return(response);
}
public IndexController(
ILogger <IndexController> logger,
IServiceManager serviceManager,
IServiceRouter router)
{
this.logger = logger;
this.serviceManager = serviceManager;
this.serviceRouter = router;
}
public virtual async Task <TResult> QueryAsync(TRequest request, IServiceRouter router, RequestContext context)
{
return(await new Task <TResult>(() =>
{
using (ContextScope scope = new ContextScope(context))
{
return Query(request, router, scope.Current);
}
}).ConfigureAwait(false));
}
public override void Command(SetPasswordCommand request, IServiceRouter router, RequestContext context)
{
Principal principal = _storage.GetPrincipalById(request.PrincipalId);
principal.Password = Password.CreateHash(request.Password);
_storage.SavePrincipal(principal);
router.Push <PasswordSetEvent>(evt => { evt.PrincipalId = request.PrincipalId; });
}
public virtual async Task CommandAsync(TRequest request, IServiceRouter router, RequestContext context)
{
await new Task(() =>
{
using (ContextScope scope = new ContextScope(context))
{
Command(request, router, scope.Current);
}
}).ConfigureAwait(false);
}
public DefaultRpcClient(
//IOptions<RpcClientOptions> clientOptions,
IServiceRouter serviceRouter,
ITransportFactory <AmpMessage> transportFactory,
IClientMessageHandler <AmpMessage> handler,
ILogger <DefaultRpcClient> logger
)
{
//_clientOptions = clientOptions.Value ?? new RpcClientOptions();
this._serviceRouter = serviceRouter;
this._transportFactory = transportFactory;
this._handler = handler;
this._logger = logger;
}
public override void Command(PatchCommand <Identity> request, IServiceRouter router, RequestContext context)
{
Identity identity = _storage.GetIdentityById(request.ObjectId);
request.Patch.ApplyTo(identity);
_storage.SaveIdentity(identity, request.NewVersion);
router.Push <IdentityUpdatedEvent>(evt =>
{
evt.IdentityId = identity.Id;
evt.NewVersion = request.NewVersion;
evt.OldVersion = identity.Version;
});
}
public Message MessageRoute(Message value)
{
logger.Debug("START");
try
{
MessageVersion clientMsgVersion = value.Version;
logger.DebugFormat("Azione: {0}", value.Headers.Action);
string endpointAddressUrl = CreateEndpoint(value);
if (string.IsNullOrEmpty(endpointAddressUrl))
{
logger.Error("Endpoint url nullo o vuoto");
throw new Exception("Endpoint url nullo o vuoto");
}
logger.DebugFormat("Endpoint puntato: {0}", endpointAddressUrl);
Binding bind = CreateBindingByConfig();
Uri u = new Uri(endpointAddressUrl);
EndpointAddress endpointAddress = new EndpointAddress(u, EndpointIdentity.CreateDnsIdentity(ConfigurationMgr.dnsIdentity));
ChannelFactory <IServiceRouter> ch = new ChannelFactory <IServiceRouter>(bind, endpointAddress);
SetClientCredential(ch.Credentials);
IServiceRouter router = ch.CreateChannel();
Message toSend = TransformInputMessage(value, EnvelopeVersion.Soap12);
logger.Debug("Creato il messaggio da inviare");
Message toReply = router.MessageRoute(toSend);
logger.Debug("Ricevuto il messaggio di risposta");
((IChannel)router).Close();
ch.Close();
logger.Debug("END");
return(TransformOutputMessage(toReply, clientMsgVersion));
}
catch (Exception ex)
{
logger.ErrorFormat("Errore nel metodo MessageRoute: {0}", ex.Message);
logger.Error(ex.ToString());
throw new FaultException(ex.Message);
}
}
public override DecryptResponse Query(DecryptRequest request, IServiceRouter router, RequestContext context)
{
DecryptResponse response = new DecryptResponse();
using (SymmetricAlgorithm alg = SymmetricAlgorithm.Create(request.Algorithm))
{
alg.IV = request.IV;
alg.Key = request.Key;
using (ICryptoTransform transform = alg.CreateEncryptor())
{
using (MemoryStream memoryStream = new MemoryStream())
{
memoryStream.Write(request.CipherText, 0, request.CipherText.Length);
memoryStream.Flush();
List <byte> bytes = new List <byte>();
using (CryptoStream stream = new CryptoStream(memoryStream, transform, CryptoStreamMode.Read))
{
int readByte;
while ((readByte = stream.ReadByte()) >= 0)
{
bytes.Add((byte)readByte);
}
}
response.ClearText = bytes.ToArray();
}
}
}
return(response);
}
public override EncryptResponse Query(EncryptRequest request, IServiceRouter router, RequestContext context)
{
EncryptResponse response = new EncryptResponse();
using (SymmetricAlgorithm alg = SymmetricAlgorithm.Create(request.Algorithm))
{
if (request.IV != null)
{
alg.IV = request.IV;
}
else
{
alg.GenerateIV();
response.IV = alg.IV;
}
alg.Key = request.Key;
using (ICryptoTransform transform = alg.CreateEncryptor())
{
using (MemoryStream memoryStream = new MemoryStream())
{
using (CryptoStream stream = new CryptoStream(memoryStream, transform, CryptoStreamMode.Write))
{
stream.Write(request.ClearText, 0, request.ClearText.Length);
stream.Flush();
}
response.CipherText = memoryStream.ToArray();
}
}
}
return(response);
}
public override GenerateTokenResponse Query(GenerateTokenRequest request, IServiceRouter router, RequestContext context)
{
List <Token> tokens = new List <Token>();
foreach (var token in request.Tokens)
{
DateTime issued = _clock.GetCurrentInstant().ToDateTimeUtc();
string composite = $"prin:{token.PrincipalId : N}|issued:{issued : yyyyMMddHHmmss}|expire:{token.Expiration: yyyyMMddHHmmss}|type:{token.Type : G}";
byte[] bytes = Encoding.ASCII.GetBytes(composite);
EncryptResponse response = router.Query <EncryptRequest, EncryptResponse>(new EncryptRequest()
{
Algorithm = request.Algorithm,
ClearText = bytes,
Key = request.Key
});
Token newToken = new Token()
{
Data = Convert.ToBase64String(response.CipherText),
Type = token.Type,
Expiration = token.Expiration,
Issued = issued,
PrincipalId = token.PrincipalId
};
tokens.Add(newToken);
}
return(new GenerateTokenResponse()
{
Tokens = tokens
});
}
public abstract void Command(TRequest request, IServiceRouter router, RequestContext context);
public override void Command(CreateCommand <Principal> request, IServiceRouter router, RequestContext context)
{
_storage.CreatePrincipal(request.Object);
router.Push <PrincipalCreatedEvent>(evt => { evt.PrincipalId = request.Object.Id; });
}
public override CheckCredentialResponse Query(CheckCredentialRequest request, IServiceRouter router, RequestContext context)
{
CheckCredentialResponse response = new CheckCredentialResponse();
Principal principal = _principalStorage.GetPrincipalByUsername(request.Username);
if (principal == null)
{
return(response);
}
response.PrincipalId = principal.Id;
if (Password.VerifyPassword(request.Password, principal.Password))
{
response.Success = true;
}
return(response);
}
public override ValidatePatchResponse Query(ValidatePatchRequest <Identity> request, IServiceRouter router, RequestContext context)
{
throw new System.NotImplementedException();
}
public SecurityController(IWebContext context, IServiceRouter router) : base(context)
{
_router = router;
}
public override void Command(CreateCommand <Identity> request, IServiceRouter router, RequestContext context)
{
throw new NotImplementedException();
}
public abstract TResult Query(TRequest request, IServiceRouter router, RequestContext context);
public FileController(IWebContext context, IServiceRouter router) : base(context)
{
_router = router;
}
