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