public PiraeusCoapClient(CoapConfig config, IChannel channel, SecurityTokenType tokenType, string securityToken, ICoapRequestDispatch dispatcher = null) : this(config, channel, dispatcher) { this.tokenType = tokenType; this.securityToken = securityToken; usedToken = false; }
public async Task Invoke(HttpContext context) { if (!context.WebSockets.IsWebSocketRequest) { return; } BasicAuthenticator basicAuthn = new BasicAuthenticator(); SecurityTokenType tokenType = Enum.Parse <SecurityTokenType>(config.ClientTokenType, true); basicAuthn.Add(tokenType, config.ClientSymmetricKey, config.ClientIssuer, config.ClientAudience, context); IAuthenticator authn = basicAuthn; WebSocket socket = await context.WebSockets.AcceptWebSocketAsync(); source = new CancellationTokenSource(); ProtocolAdapter adapter = ProtocolAdapterFactory.Create(config, graphManager, context, socket, logger, authn, source.Token); container.Add(adapter.Channel.Id, adapter); adapter.OnClose += Adapter_OnClose; adapter.OnError += Adapter_OnError; adapter.Init(); await adapter.Channel.OpenAsync(); await next(context); await logger.LogInformationAsync("Exiting Web socket invoke."); }
public void Add(SecurityTokenType type, string signingKey, string issuer = null, string audience = null, HttpContext context = null) { this.context = context; if (!container.ContainsKey(type.ToString())) { Tuple <string, string, string> tuple = new Tuple <string, string, string>(signingKey, issuer, audience); container.Add(type.ToString(), tuple); } }
public bool Authenticate(SecurityTokenType type, byte[] token) { if (token != null) { return Authenticate(type, type == SecurityTokenType.X509 ? Convert.ToBase64String(token) : Encoding.UTF8.GetString(token)); } return Authenticate(type, token); }
public bool Authenticate(string tokenType, string token) { SecurityTokenType tt = (SecurityTokenType)Enum.Parse(typeof(SecurityTokenType), tokenType, true); bootstrapTokenType = tt; bootstrapToken = token; HasBootstrapToken = true; IsAuthenticated = Config.Authenticator.Authenticate(tt, token); return(IsAuthenticated); }
public ConnectController(PiraeusConfig config, IClusterClient client, ILog logger) { this.config = config; BasicAuthenticator basicAuthn = new BasicAuthenticator(); SecurityTokenType tokenType = Enum.Parse <SecurityTokenType>(config.ClientTokenType, true); basicAuthn.Add(tokenType, config.ClientSymmetricKey, config.ClientIssuer, config.ClientAudience); authn = basicAuthn; graphManager = new GraphManager(client); this.logger = logger; }
public UdpServerListener(PiraeusConfig config, IPEndPoint localEP, CancellationToken token) { this.config = config; this.localEP = localEP; this.token = token; cache = new Dictionary <string, Tuple <ProtocolAdapter, CancellationTokenSource> >(); container = new Dictionary <string, string>(); SecurityTokenType stt = System.Enum.Parse <SecurityTokenType>(config.ClientTokenType, true); BasicAuthenticator bauthn = new BasicAuthenticator(); bauthn.Add(stt, config.ClientSymmetricKey, config.ClientIssuer, config.ClientAudience); authn = bauthn; }
public bool Authenticate(SecurityTokenType type, string token) { if (container.ContainsKey(SecurityTokenType.NONE.ToString()) && type == SecurityTokenType.NONE) { return true; } if (token != null && container.ContainsKey(type.ToString())) { Tuple<string, string, string> tuple = container[type.ToString()]; return SecurityTokenValidator.Validate(token, type, tuple.Item1, tuple.Item2, tuple.Item3, context); } return false; }
public TcpServerListener(IPEndPoint localEP, PiraeusConfig config, ILogger logger = null, CancellationToken token = default(CancellationToken)) { serverIP = localEP.Address; serverPort = localEP.Port; listener = new TcpListener(localEP); this.token = token; dict = new Dictionary <string, ProtocolAdapter>(); this.config = config; this.logger = logger; if (config.ClientTokenType != null && config.ClientSymmetricKey != null) { SecurityTokenType stt = Enum.Parse <SecurityTokenType>(config.ClientTokenType, true); BasicAuthenticator bauthn = new BasicAuthenticator(); bauthn.Add(stt, config.ClientSymmetricKey, config.ClientIssuer, config.ClientAudience); this.authn = bauthn; } }
public static bool Validate(string tokenString, SecurityTokenType tokenType, string securityKey, string issuer = null, string audience = null, HttpContext context = null) { if (tokenType == SecurityTokenType.NONE) { return(false); } if (tokenType == SecurityTokenType.JWT) { return(ValidateJwt(tokenString, securityKey, issuer, audience, context)); } byte[] certBytes = Convert.FromBase64String(tokenString); X509Certificate2 cert = new X509Certificate2(certBytes); return(ValidateCertificate(cert, context)); }
public static SecurityTokenReference Get(XmlDocument envelopeDocument, SecurityTokenType type, ICertificateRepository certificateRepository) { XmlElement keyInfoElement; switch (type) { case SecurityTokenType.Signing: keyInfoElement = envelopeDocument.SelectSingleNode( @"//*[local-name()='Header']/*[local-name()='Security']/*[local-name()='Signature']/*[local-name()='KeyInfo']/*[local-name()='SecurityTokenReference']") as XmlElement; break; case SecurityTokenType.Encryption: keyInfoElement = envelopeDocument.SelectSingleNode( @"//*[local-name()='Header']/*[local-name()='Security']/*[local-name()='EncryptedKey']/*[local-name()='KeyInfo']/*[local-name()='SecurityTokenReference']") as XmlElement; break; default: throw new ArgumentOutOfRangeException(nameof(type)); } if (keyInfoElement == null) { return(null); } if (HasEnvelopeTag(keyInfoElement, securityTokenNodeName: "Reference")) { return(new BinarySecurityTokenReference(keyInfoElement)); } if (HasEnvelopeTag(keyInfoElement, securityTokenNodeName: "KeyIdentifier")) { return(new KeyIdentifierSecurityTokenReference(keyInfoElement, certificateRepository)); } if (HasEnvelopeTag(keyInfoElement, securityTokenNodeName: "X509Data")) { return(new IssuerSecurityTokenReference(keyInfoElement, certificateRepository)); } throw new NotSupportedException("Unable to retrieve SecurityTokenReference of type " + keyInfoElement.OuterXml); }
public TcpServerListener(IPAddress address, int port, PiraeusConfig config, ILogger logger = null, CancellationToken token = default(CancellationToken)) { serverIP = address; serverPort = port; listener = new TcpListener(address, port); listener.ExclusiveAddressUse = false; this.token = token; dict = new Dictionary <string, ProtocolAdapter>(); this.config = config; this.logger = logger; if (config.ClientTokenType != null && config.ClientSymmetricKey != null) { SecurityTokenType stt = (SecurityTokenType)System.Enum.Parse(typeof(SecurityTokenType), config.ClientTokenType, true); BasicAuthenticator bauthn = new BasicAuthenticator(); bauthn.Add(stt, config.ClientSymmetricKey, config.ClientIssuer, config.ClientAudience); this.authn = bauthn; } }
public UdpServerListener(IPEndPoint localEP, PiraeusConfig config, OrleansConfig orleansConfig, ILog logger = null, CancellationToken token = default) { this.localEP = localEP; listener = new UdpClient(); this.token = token; dict = new Dictionary <string, ProtocolAdapter>(); this.config = config; this.logger = logger; graphManager = new GraphManager(orleansConfig); if (config.ClientTokenType != null && config.ClientSymmetricKey != null) { SecurityTokenType stt = Enum.Parse <SecurityTokenType>(config.ClientTokenType, true); BasicAuthenticator bauthn = new BasicAuthenticator(); bauthn.Add(stt, config.ClientSymmetricKey, config.ClientIssuer, config.ClientAudience); authn = bauthn; } cache = MemoryCache.Default; }
public static SecurityTokenType ToSecurityTokenType(this SecurityTokenType type, string tokenType) { return((SecurityTokenType)Enum.Parse(typeof(SecurityTokenType), tokenType, true)); }
public bool Remove(SecurityTokenType type) { return(container.Remove(type.ToString())); }