public Task ValidateConnectionAsync(MqttConnectionValidatorContext context) { try { var pythonContext = new PythonDictionary { { "endpoint", context.Endpoint }, { "is_secure_connection", context.IsSecureConnection }, { "client_id", context.ClientId }, { "username", context.Username }, { "password", context.Password }, { "raw_password", new Bytes(context.RawPassword ?? new byte[0]) }, { "clean_session", context.CleanSession }, { "authentication_method", context.AuthenticationMethod }, { "authentication_data", new Bytes(context.AuthenticationData ?? new byte[0]) }, { "result", PythonConvert.Pythonfy(context.ReasonCode) } }; _pythonScriptHostService.InvokeOptionalFunction("on_validate_client_connection", pythonContext); context.ReasonCode = PythonConvert.ParseEnum <MqttConnectReasonCode>((string)pythonContext["result"]); } catch (Exception exception) { _logger.LogError(exception, "Error while validating client connection."); context.ReasonCode = MqttConnectReasonCode.UnspecifiedError; } return(Task.CompletedTask); }
/// <summary> /// Check if JWT is enabled and validate the JWT if required. /// If JWT is not enabled, authorization is granted if username & password are emtpy. /// </summary> private static void ValidateUserAndPassword(MqttConnectionValidatorContext mqttConnectionValidatorContext) { mqttConnectionValidatorContext.ReasonCode = MqttConnectReasonCode.Success; Logger.Info($"Connection from client '{mqttConnectionValidatorContext.ClientId}'"); bool validateJWT = true; if (string.IsNullOrEmpty(mqttConnectionValidatorContext.Username)) { validateJWT = false; Logger.Info("Connection request: username is null."); } else { Logger.Info($"Username: {mqttConnectionValidatorContext.Username}"); } if (string.IsNullOrEmpty(mqttConnectionValidatorContext.Password)) { validateJWT = false; Logger.Info("Connection request: username is null."); } else { Logger.Info($"Password: {mqttConnectionValidatorContext.Password}"); } if (validateJWT) { JSONWebToken tokenHandler = new JSONWebToken(); tokenHandler.IsValid(mqttConnectionValidatorContext.Password); } }
internal void Server_ClientConnectionValidator(object sender, MqttClientConnectionValidatorEventArgs e) { MqttConnectionValidatorContext obj = e.Context; Uri uri = new Uri("mqtt://" + obj.Endpoint); if (string.IsNullOrEmpty(obj.Username) && uri.IsLoopback) { obj.ReturnCode = MQTTnet.Protocol.MqttConnectReturnCode.ConnectionAccepted; _logger.LogInformation($"Loopback {obj.Endpoint}, ConnectionAccepted"); } else { _logger.LogInformation($"ClientId={obj.ClientId},Endpoint={obj.Endpoint},Username={obj.Username},Password={obj.Password},WillMessage={obj.WillMessage?.ConvertPayloadToString()}"); var mcr = _dbContext.DeviceIdentities.FirstOrDefault(mc => (mc.IdentityType == IdentityType.AccessToken && mc.IdentityId == obj.Username) || (mc.IdentityType == IdentityType.DevicePassword && mc.IdentityId == obj.Username && mc.IdentityValue == obj.Password)); if (mcr != null) { try { var device = mcr.Device; Devices.Add(e.Context.ClientId, device); } catch (Exception ex) { _logger.LogError(ex, "ConnectionRefusedServerUnavailable {0}", ex.Message); obj.ReturnCode = MQTTnet.Protocol.MqttConnectReturnCode.ConnectionRefusedServerUnavailable; } } else { obj.ReturnCode = MQTTnet.Protocol.MqttConnectReturnCode.ConnectionRefusedBadUsernameOrPassword; _logger.LogInformation($"Bad username or password {obj.Username},connection {obj.Endpoint} refused"); } } }
async Task <MqttConnectionValidatorContext> ValidateConnection(MqttConnectPacket connectPacket, IMqttChannelAdapter channelAdapter) { var context = new MqttConnectionValidatorContext(connectPacket, channelAdapter) { SessionItems = new ConcurrentDictionary <object, object>() }; var connectionValidator = _options.ConnectionValidator; if (connectionValidator == null) { context.ReasonCode = MqttConnectReasonCode.Success; return(context); } await connectionValidator.ValidateConnectionAsync(context).ConfigureAwait(false); // Check the client ID and set a random one if supported. if (string.IsNullOrEmpty(connectPacket.ClientId) && channelAdapter.PacketFormatterAdapter.ProtocolVersion == MqttProtocolVersion.V500) { connectPacket.ClientId = context.AssignedClientIdentifier; } if (string.IsNullOrEmpty(connectPacket.ClientId)) { context.ReasonCode = MqttConnectReasonCode.ClientIdentifierNotValid; } return(context); }
public Task ValidateConnectionAsync(MqttConnectionValidatorContext context) { try { var pythonContext = new PythonDictionary { { "client_id", context.ClientId }, { "endpoint", context.Endpoint }, { "is_secure_connection", context.IsSecureConnection }, { "username", context.Username }, { "password", context.Password }, { "result", PythonConvert.Pythonfy(context.ReturnCode) } }; _pythonScriptHostService.InvokeOptionalFunction("on_validate_client_connection", pythonContext); context.ReturnCode = PythonConvert.ParseEnum <MqttConnectReturnCode>((string)pythonContext["result"]); } catch (Exception exception) { _logger.LogError(exception, "Error while validating client connection."); } return(Task.CompletedTask); }
public Task ValidateConnectionAsync( MqttConnectionValidatorContext context) { var currentUser = _repo.GetUser(context.Username); if (currentUser == null) { context.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword; LogMessage(context); return(Task.CompletedTask); } if (context.Username != currentUser.Username) { context.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword; LogMessage(context); return(Task.CompletedTask); } if (context.Password != currentUser.Password) { context.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword; LogMessage(context); return(Task.CompletedTask); } context.ReasonCode = MqttConnectReasonCode.Success; LogMessage(context); return(Task.CompletedTask); }
public Task ValidateConnectionAsync(MqttConnectionValidatorContext context) { try { if (!_mqttSettingsModel.RequireClientAuthentication) { context.ReasonCode = MqttConnectReasonCode.Success; _logger.LogInformation($"New connection from Endpoint: {context.Endpoint}, ClientId: {context.ClientId}"); return(Task.CompletedTask); } // Search for matching credentials foreach (var clientCredential in _mqttSettingsModel.ClientCredentials) { if (context.Username != null && context.Username.Equals(clientCredential.UserName, StringComparison.OrdinalIgnoreCase) && context.Password == clientCredential.Password) { context.ReasonCode = MqttConnectReasonCode.Success; _logger.LogInformation($"New validated connection from Endpoint: {context.Endpoint}, ClientId: {context.ClientId}"); return(Task.CompletedTask); } } // Otherwise, reject connection context.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword; _logger.LogWarning($"Invalid connection attempt from Endpoint: {context.Endpoint}, ClientId: {context.ClientId}, Username: {context.Username}"); } catch (Exception ex) { _logger.LogError(ex, "Error while validating client connection."); context.ReasonCode = MqttConnectReasonCode.UnspecifiedError; } return(Task.CompletedTask); }
private async Task ConnectionValidation(MqttConnectionValidatorContext context) { nlogger.Debug("connection validation."); if (context.ClientId.Length < 10) { nlogger.Error("ClientId.Length < 10"); context.ReasonCode = MqttConnectReasonCode.ClientIdentifierNotValid; return; } if (!context.Username.Equals(mqttUsername)) { nlogger.Error("Username is not admin"); context.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword; return; } if (!context.Password.Equals(mqttPassword)) { nlogger.Error("Password is not public"); context.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword; return; } nlogger.Debug("connection validation success."); context.ReasonCode = MqttConnectReasonCode.Success; }
/// <summary> /// Logs the message from the MQTT connection validation context. /// </summary> /// <param name="context">The MQTT connection validation context.</param> /// <param name="showPassword">A <see cref="bool"/> value indicating whether the password is written to the log or not.</param> private static void LogMessage(MqttConnectionValidatorContext context, bool showPassword) { if (context == null) { return; } if (showPassword) { Logger.Information( "New connection: ClientId = {@ClientId}, Endpoint = {@Endpoint}, Username = {@UserName}, Password = {@Password}, CleanSession = {@CleanSession}", context.ClientId, context.Endpoint, context.Username, context.Password, context.CleanSession); } else { Logger.Information( "New connection: ClientId = {@ClientId}, Endpoint = {@Endpoint}, Username = {@UserName}, CleanSession = {@CleanSession}", context.ClientId, context.Endpoint, context.Username, context.CleanSession); } }
public MqttConnAckPacket CreateConnAckPacket(MqttConnectionValidatorContext connectionValidatorContext) { if (connectionValidatorContext == null) { throw new ArgumentNullException(nameof(connectionValidatorContext)); } return(new MqttConnAckPacket { ReasonCode = connectionValidatorContext.ReasonCode, Properties = new MqttConnAckPacketProperties { RetainAvailable = true, SubscriptionIdentifiersAvailable = true, SharedSubscriptionAvailable = false, TopicAliasMaximum = ushort.MaxValue, WildcardSubscriptionAvailable = true, UserProperties = connectionValidatorContext.ResponseUserProperties, AuthenticationMethod = connectionValidatorContext.AuthenticationMethod, AuthenticationData = connectionValidatorContext.ResponseAuthenticationData, AssignedClientIdentifier = connectionValidatorContext.AssignedClientIdentifier, ReasonString = connectionValidatorContext.ReasonString, ServerReference = connectionValidatorContext.ServerReference } }); }
public async Task ValidateConnectionAsync( MqttConnectionValidatorContext context) { var currentUser = _repo.GetUser(context.Username); if (currentUser == null) { context.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword; await LogMessage(context); return; } if (context.Username != currentUser.Username) { context.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword; await LogMessage(context); return; } if (context.Password != currentUser.Password) { context.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword; await LogMessage(context); return; } context.ReasonCode = MqttConnectReasonCode.Success; //_repo. await LogMessage(context, true); return; }
private void OnNewConnection(MqttConnectionValidatorContext context) { AppendLog($"Client connected: {context.ClientId} "); //AppendText($"Timestamp: {DateTime.Now:O} | Topic: {x.ApplicationMessage.Topic} | Payload: {x.ApplicationMessage.ConvertPayloadToString()} | QoS: {x.ApplicationMessage.QualityOfServiceLevel}"); //AppendText( ); }
public Task ValidateConnectionAsync(MqttConnectionValidatorContext context) { Handler.HandleClientConnectionValidatorAsync(new MqttServerClientConnectionValidatorEventArgs() { Context = context }); return(Task.CompletedTask); }
/// <summary> /// Initializes a new instance of the <see cref="SimpleMqttConnectionValidatorContext"/> class. /// </summary> /// <param name="context">The context.</param> public SimpleMqttConnectionValidatorContext(MqttConnectionValidatorContext context) { this.UserName = context.Username; this.ClientId = context.ClientId; this.Password = context.Password; this.CleanSession = context.CleanSession; this.Endpoint = context.Endpoint; }
public Task ValidateConnectionAsync(MqttConnectionValidatorContext context) { if (context.Username != _clientSettings.UserName || context.Password != _clientSettings.Password) { return(Task.FromResult(context.ReasonCode = MQTTnet.Protocol.MqttConnectReasonCode.BadUserNameOrPassword)); } return(Task.FromResult(context.ReasonCode = MQTTnet.Protocol.MqttConnectReasonCode.Success)); }
/// <summary> /// Validates the connection. /// </summary> /// <param name="context">The context.</param> private async void ValidateConnection(MqttConnectionValidatorContext context) { var currentUser = await this.userRepository.GetUserByName(context.Username).ConfigureAwait(false); if (currentUser == null) { context.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword; LogMessage(context, true); return; } if (context.Username != currentUser.UserName) { context.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword; LogMessage(context, true); return; } var hashingResult = Hasher.VerifyHashedPassword( currentUser, currentUser.PasswordHash, context.Password); if (hashingResult == PasswordVerificationResult.Failed) { context.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword; LogMessage(context, true); return; } if (!currentUser.ValidateClientId) { context.ReasonCode = MqttConnectReasonCode.Success; context.SessionItems.Add(context.ClientId, currentUser); LogMessage(context, false); return; } if (string.IsNullOrWhiteSpace(currentUser.ClientIdPrefix)) { if (context.ClientId != currentUser.ClientId) { context.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword; LogMessage(context, true); return; } context.SessionItems.Add(currentUser.ClientId, currentUser); } else { context.SessionItems.Add(currentUser.ClientIdPrefix, currentUser); } context.ReasonCode = MqttConnectReasonCode.Success; LogMessage(context, false); }
/// <summary> /// Logs the message from the MQTT connection validation context. /// </summary> /// <param name="context">The MQTT connection validation context.</param> private static void LogMessage(ILogger <MQTTService> logger, MqttConnectionValidatorContext context) { if (context == null) { return; } logger.LogInformation( $"New connection: ClientId = {context.ClientId}, Endpoint = {context.Endpoint}," + $" Username = {context.Username}, CleanSession = {context.CleanSession}"); }
private void ConnectionValidationHandler(MqttConnectionValidatorContext eventArgs) { if (_connected.ContainsKey(eventArgs.ClientId)) { eventArgs.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword; return; } _connected[eventArgs.ClientId] = true; eventArgs.ReasonCode = MqttConnectReasonCode.Success; return; }
/// <summary> /// 鉴权身份认证 /// </summary> /// <param name="cxt"></param> public void EH_ConnectionValidator(MqttConnectionValidatorContext cxt) { if (string.IsNullOrEmpty(ServerAuth_Username) || string.IsNullOrEmpty(ServerAuth_Password)) { cxt.ReasonCode = MQTTnet.Protocol.MqttConnectReasonCode.BadUserNameOrPassword; } else if (cxt.Username != ServerAuth_Username || cxt.Password != ServerAuth_Password) { cxt.ReasonCode = MQTTnet.Protocol.MqttConnectReasonCode.BadUserNameOrPassword; } cxt.ReasonCode = MQTTnet.Protocol.MqttConnectReasonCode.Success; }
/// <summary> /// Validates the connection. /// </summary> /// <param name="context">The context.</param> private void ValidateConnection(MqttConnectionValidatorContext context) { if (this.cancellationToken.IsCancellationRequested) { return; } var repositoryGrain = this.clusterClient.GetGrain <IMqttRepositoryGrain>(0); var connectionValid = repositoryGrain.ProceedConnect(new SimpleMqttConnectionValidatorContext(context)).Result; context.ReasonCode = connectionValid ? MqttConnectReasonCode.Success : MqttConnectReasonCode.BadUserNameOrPassword; }
public MqttConnAckPacket CreateConnAckPacket(MqttConnectionValidatorContext connectionValidatorContext) { if (connectionValidatorContext == null) { throw new ArgumentNullException(nameof(connectionValidatorContext)); } return(new MqttConnAckPacket { ReturnCode = new MqttConnectReasonCodeConverter().ToConnectReturnCode(connectionValidatorContext.ReasonCode) }); }
private void ConnectEventAction(MqttConnectionValidatorContext context) { if (!(context.Username == "admin")) { context.ReturnCode = MQTTnet.Protocol.MqttConnectReturnCode.ConnectionRefusedBadUsernameOrPassword; return; } if (context.Password != "123456") { context.ReturnCode = MQTTnet.Protocol.MqttConnectReturnCode.ConnectionRefusedBadUsernameOrPassword; return; } }
void ValidateClientConnection(MqttConnectionValidatorContext context) { context.ReasonCode = MQTTnet.Protocol.MqttConnectReasonCode.Success; if (_options.BlockedClients == null) { return; } if (_options.BlockedClients.Contains(context.ClientId ?? string.Empty)) { context.ReasonCode = MQTTnet.Protocol.MqttConnectReasonCode.Banned; } }
public bool Validate(MqttConnectionValidatorContext context) { var optionsBuilder = new DbContextOptionsBuilder <HubDbContext>(); optionsBuilder.UseSqlServer(_configuration.GetConnectionString("HubDatabase")); HubUser user; using (var dbContext = new HubDbContext(optionsBuilder.Options)) { user = dbContext.HubUser.SingleOrDefault(new Validator(context).Predicate); } return(user != null && "HUR-ACT" == user.StatusCode); }
public bool Validate(MqttConnectionValidatorContext context) { var optionsBuilder = new DbContextOptionsBuilder <HubDbContext>(); optionsBuilder.UseSqlServer(_configuration.GetConnectionString("HubDatabase")); Agent agent; using (var dbContext = new HubDbContext(optionsBuilder.Options)) { agent = dbContext.Agent.FirstOrDefault(new Validator(context).Predicate); } return(agent != null); }
/// <summary> /// Validates the MQTT connection. /// </summary> /// <param name="context">The context.</param> /// <returns>A <see cref="Task"/> representing any asynchronous operation.</returns> public async Task ValidateConnectionAsync(MqttConnectionValidatorContext context) { try { var repositoryGrain = clusterClient.GetGrain <IMqttRepositoryGrain>(0); var connectionValid = await repositoryGrain.ProceedConnect(new SimpleMqttConnectionValidatorContext(context)); context.ReasonCode = connectionValid ? MqttConnectReasonCode.Success : MqttConnectReasonCode.BadUserNameOrPassword; } catch (Exception ex) { this.logger.Error("An error occurred: {@ex}.", ex); } }
public MqttConnAckPacket CreateConnAckPacket(MqttConnectionValidatorContext connectionValidatorContext) { return(new MqttConnAckPacket { ReasonCode = connectionValidatorContext.ReasonCode, Properties = new MqttConnAckPacketProperties { UserProperties = connectionValidatorContext.ResponseUserProperties, AuthenticationMethod = connectionValidatorContext.AuthenticationMethod, AuthenticationData = connectionValidatorContext.ResponseAuthenticationData, AssignedClientIdentifier = connectionValidatorContext.AssignedClientIdentifier, ReasonString = connectionValidatorContext.ReasonString } }); }
private void AuthenticateUser(MqttConnectionValidatorContext c) { Logger.LogDebug(LogCategory.RestServe, $"Attempting to authenticate {EboEwsSettings.UserName} with password {EboEwsSettings.Password}"); try { var client = MongooseObjectFactory.Current.GetInstance <IManagedEwsClient>(); client.EwsVersionImplemented(EboEwsSettings); c.ReturnCode = MqttConnectReturnCode.ConnectionAccepted; } catch (Exception ex) { Logger.LogError(LogCategory.RestServe, ex); c.ReturnCode = MqttConnectReturnCode.ConnectionRefusedBadUsernameOrPassword; } }
private Task ConnectEventFunc(MqttConnectionValidatorContext context) { return(Task.Run(() => { if (!(context.Username == "admin")) { context.ReturnCode = MQTTnet.Protocol.MqttConnectReturnCode.ConnectionRefusedBadUsernameOrPassword; return; } if (context.Password != "123456") { context.ReturnCode = MQTTnet.Protocol.MqttConnectReturnCode.ConnectionRefusedBadUsernameOrPassword; return; } })); }
/// <summary> /// Logs the message from the MQTT connection validation context. /// </summary> /// <param name="context">The MQTT connection validation context.</param> /// <param name="showPassword">A <see cref="bool"/> value indicating whether the password is written to the log or not.</param> private static void LogMessage(MqttConnectionValidatorContext context, bool showPassword) { if (showPassword) { Log.Information( $"New connection: ClientId = {context.ClientId}, Endpoint = {context.Endpoint}," + $" Username = {context.Username}, Password = {context.Password}," + $" CleanSession = {context.CleanSession}"); } else { Log.Information( $"New connection: ClientId = {context.ClientId}, Endpoint = {context.Endpoint}," + $" Username = {context.Username}, CleanSession = {context.CleanSession}"); } }