public async Task GetDeviceAndModuleOnBehalfOfAsync([FromRoute] string actorDeviceId, [FromRoute] string actorModuleId, [FromBody] IdentityOnBehalfOfRequest request)
{
actorDeviceId = WebUtility.UrlDecode(Preconditions.CheckNonWhiteSpace(actorDeviceId, nameof(actorDeviceId)));
actorModuleId = WebUtility.UrlDecode(Preconditions.CheckNonWhiteSpace(actorModuleId, nameof(actorModuleId)));
Preconditions.CheckNonWhiteSpace(request.AuthChain, nameof(request.AuthChain));
if (actorModuleId != Constants.EdgeHubModuleId)
{
// Only child EdgeHubs are allowed to act OnBehalfOf of devices/modules.
var result = new EdgeHubScopeResultError(HttpStatusCode.Unauthorized, Events.UnauthorizedActor(actorDeviceId, actorModuleId));
await this.SendResponse(result.Status, JsonConvert.SerializeObject(result));
}
IHttpRequestAuthenticator authenticator = await this.authenticatorGetter;
HttpAuthResult authResult = await authenticator.AuthenticateAsync(actorDeviceId, Option.Some(actorModuleId), Option.Some(request.AuthChain), this.HttpContext);
if (authResult.Authenticated)
{
EdgeHubScopeResult reqResult = await this.HandleGetDeviceAndModuleOnBehalfOfAsync(actorDeviceId, actorModuleId, request);
await this.SendResponse(reqResult.Status, JsonConvert.SerializeObject(reqResult));
}
else
{
var result = new EdgeHubScopeResultError(HttpStatusCode.Unauthorized, authResult.ErrorMessage);
await this.SendResponse(result.Status, JsonConvert.SerializeObject(result));
}
}
public async Task DeleteModuleAsync(
[FromRoute] string deviceId,
[FromRoute] string moduleId)
{
try
{
Events.ReceivedRequest(nameof(this.DeleteModuleAsync), deviceId, moduleId);
try
{
deviceId = WebUtility.UrlDecode(Preconditions.CheckNonWhiteSpace(deviceId, nameof(deviceId)));
moduleId = WebUtility.UrlDecode(Preconditions.CheckNonWhiteSpace(moduleId, nameof(moduleId)));
}
catch (Exception ex)
{
Events.BadRequest(nameof(this.DeleteModuleAsync), ex.Message);
await this.SendResponseAsync(HttpStatusCode.BadRequest, FormatErrorResponseMessage(ex.Message));
return;
}
IHttpRequestAuthenticator authenticator = await this.authenticatorGetter;
if (!await AuthenticateAsync(deviceId, Option.None <string>(), Option.None <string>(), this.HttpContext, authenticator))
{
await this.SendResponseAsync(HttpStatusCode.Unauthorized);
return;
}
IEdgeHub edgeHub = await this.edgeHubGetter;
IDeviceScopeIdentitiesCache identitiesCache = edgeHub.GetDeviceScopeIdentitiesCache();
Option <string> targetAuthChain = await identitiesCache.GetAuthChain(deviceId);
if (!targetAuthChain.HasValue)
{
Events.AuthorizationFail_NoAuthChain(deviceId);
await this.SendResponseAsync(HttpStatusCode.Unauthorized);
return;
}
string edgeDeviceId = edgeHub.GetEdgeDeviceId();
var requestData = new DeleteModuleOnBehalfOfData($"{targetAuthChain.OrDefault()}", moduleId);
RegistryApiHttpResult result = await this.apiClient.DeleteModuleAsync(edgeDeviceId, requestData);
await this.SendResponseAsync(result.StatusCode, result.JsonContent);
Events.CompleteRequest(nameof(this.DeleteModuleAsync), edgeDeviceId, requestData.AuthChain, result);
}
catch (Exception ex)
{
Events.InternalServerError(nameof(this.DeleteModuleAsync), ex);
await this.SendResponseAsync(HttpStatusCode.InternalServerError, FormatErrorResponseMessage(ex.ToString()));
}
}
public async Task CreateOrUpdateModuleOnBehalfOfAsync(
[FromRoute] string actorDeviceId,
[FromHeader(Name = "if-match")] string ifMatchHeader,
[FromBody] CreateOrUpdateModuleOnBehalfOfData requestData)
{
try
{
Events.ReceivedOnBehalfOfRequest(nameof(this.CreateOrUpdateModuleOnBehalfOfAsync), actorDeviceId, Events.GetAdditionalInfo(requestData));
try
{
Preconditions.CheckNonWhiteSpace(actorDeviceId, nameof(actorDeviceId));
Preconditions.CheckNotNull(requestData, nameof(requestData));
Preconditions.CheckNonWhiteSpace(requestData.AuthChain, nameof(requestData.AuthChain));
Preconditions.CheckNotNull(requestData.Module, nameof(requestData.Module));
}
catch (Exception ex)
{
Events.BadRequest(nameof(this.CreateOrUpdateModuleOnBehalfOfAsync), ex.Message);
await this.SendResponseAsync(HttpStatusCode.BadRequest, FormatErrorResponseMessage(ex.ToString()));
return;
}
actorDeviceId = WebUtility.UrlDecode(actorDeviceId);
IEdgeHub edgeHub = await this.edgeHubGetter;
IHttpRequestAuthenticator authenticator = await this.authenticatorGetter;
Try <string> targetAuthChainTry = await AuthorizeOnBehalfOf(actorDeviceId, requestData.AuthChain, nameof(this.CreateOrUpdateModuleOnBehalfOfAsync), this.HttpContext, edgeHub, authenticator);
if (targetAuthChainTry.Success)
{
string targetAuthChain = targetAuthChainTry.Value;
string edgeDeviceId = edgeHub.GetEdgeDeviceId();
RegistryApiHttpResult result = await this.apiClient.PutModuleAsync(
edgeDeviceId,
new CreateOrUpdateModuleOnBehalfOfData($"{targetAuthChain}", requestData.Module),
ifMatchHeader);
await this.SendResponseAsync(result.StatusCode, result.JsonContent);
Events.CompleteRequest(nameof(this.CreateOrUpdateModuleOnBehalfOfAsync), edgeDeviceId, targetAuthChain, result);
}
else
{
await this.SendErrorResponse(targetAuthChainTry.Exception);
}
}
catch (Exception ex)
{
Events.InternalServerError(nameof(this.CreateOrUpdateModuleOnBehalfOfAsync), ex);
await this.SendResponseAsync(HttpStatusCode.InternalServerError, FormatErrorResponseMessage(ex.ToString()));
}
}
async Task <bool> AuthenticateAsync(string deviceId, Option <string> moduleId, Option <string> authChain)
{
IHttpRequestAuthenticator authenticator = await this.authenticatorGetter;
HttpAuthResult authResult = await authenticator.AuthenticateAsync(deviceId, moduleId, authChain, this.HttpContext);
if (authResult.Authenticated)
{
Events.Authenticated(deviceId, moduleId.GetOrElse(string.Empty));
return(true);
}
Events.AuthenticateFail(deviceId, moduleId.GetOrElse(string.Empty));
return(false);
}
async Task <MethodResult> InvokeMethodAsync(DirectMethodRequest directMethodRequest)
{
Events.ReceivedMethodCall(directMethodRequest);
IEdgeHub edgeHub = await this.edgeHubGetter;
MethodResult methodResult;
string currentEdgeDeviceId = edgeHub.GetEdgeDeviceId();
if (this.TryGetActorId(out string actorDeviceId, out string actorModuleId))
{
string actorId = $"{actorDeviceId}/{actorModuleId}";
if (actorDeviceId == currentEdgeDeviceId)
{
IHttpRequestAuthenticator authenticator = await this.authenticatorGetter;
HttpAuthResult authResult = await authenticator.AuthenticateAsync(actorDeviceId, Option.Some(actorModuleId), this.HttpContext);
if (authResult.Authenticated)
{
using (Metrics.TimeDirectMethod(actorDeviceId, directMethodRequest.Id))
{
DirectMethodResponse directMethodResponse = await edgeHub.InvokeMethodAsync(actorId, directMethodRequest);
Events.ReceivedMethodCallResponse(directMethodRequest, actorId);
methodResult = GetMethodResult(directMethodResponse);
}
}
else
{
methodResult = new MethodErrorResult(HttpStatusCode.Unauthorized, authResult.ErrorMessage);
}
}
else
{
methodResult = new MethodErrorResult(HttpStatusCode.Unauthorized, "Only modules on the same device can invoke DirectMethods");
}
}
else
{
methodResult = new MethodErrorResult(HttpStatusCode.BadRequest, $"Invalid header value for {Constants.ServiceApiIdHeaderKey}");
}
return(methodResult);
}
public async Task GetDevicesAndModulesInTargetDeviceScopeAsync([FromRoute] string actorDeviceId, [FromRoute] string actorModuleId, [FromBody] NestedScopeRequest request)
{
actorDeviceId = WebUtility.UrlDecode(Preconditions.CheckNonWhiteSpace(actorDeviceId, nameof(actorDeviceId)));
actorModuleId = WebUtility.UrlDecode(Preconditions.CheckNonWhiteSpace(actorModuleId, nameof(actorModuleId)));
Preconditions.CheckNonWhiteSpace(request.AuthChain, nameof(request.AuthChain));
if (actorModuleId != Constants.EdgeHubModuleId)
{
// Only child EdgeHubs are allowed to act OnBehalfOf of devices/modules.
var result = new EdgeHubScopeResultError(HttpStatusCode.Unauthorized, Events.UnauthorizedActor(actorDeviceId, actorModuleId));
await this.SendResponse(result.Status, JsonConvert.SerializeObject(result));
}
string authChain = request.AuthChain;
string[] ids = AuthChainHelpers.GetAuthChainIds(authChain);
if (ids.Length == 1)
{
// A child EdgeHub can use its module credentials to calls upstream
// OnBehalfOf its device identity, so the auth-chain would just have
// one element denoting the target device scope but no actor.
// However, the auth stack requires an actor to be specified for OnBehalfOf
// connections, so we manually add the actor to the auth-chain for this
// special case.
authChain = $"{ids[0]}/{Constants.EdgeHubModuleId};{ids[0]}";
}
IHttpRequestAuthenticator authenticator = await this.authenticatorGetter;
HttpAuthResult authResult = await authenticator.AuthenticateAsync(actorDeviceId, Option.Some(actorModuleId), Option.Some(authChain), this.HttpContext);
if (authResult.Authenticated)
{
EdgeHubScopeResult reqResult = await this.HandleDevicesAndModulesInTargetDeviceScopeAsync(actorDeviceId, actorModuleId, request);
await this.SendResponse(reqResult.Status, JsonConvert.SerializeObject(reqResult));
}
else
{
var result = new EdgeHubScopeResultError(HttpStatusCode.Unauthorized, authResult.ErrorMessage);
await this.SendResponse(result.Status, JsonConvert.SerializeObject(result));
}
}
public async Task GetDevicesAndModulesInTargetDeviceScopeAsync([FromRoute] string actorDeviceId, [FromRoute] string actorModuleId, [FromBody] NestedScopeRequest request)
{
actorDeviceId = WebUtility.UrlDecode(Preconditions.CheckNonWhiteSpace(actorDeviceId, nameof(actorDeviceId)));
actorModuleId = WebUtility.UrlDecode(Preconditions.CheckNonWhiteSpace(actorModuleId, nameof(actorModuleId)));
IHttpRequestAuthenticator authenticator = await this.authenticatorGetter;
HttpAuthResult authResult = await authenticator.AuthenticateAsync(actorDeviceId, Option.Some(actorModuleId), this.HttpContext);
if (authResult.Authenticated)
{
EdgeHubScopeResult reqResult = await this.HandleDevicesAndModulesInTargetDeviceScopeAsync(actorDeviceId, actorModuleId, request);
await this.SendResponse(reqResult.Status, JsonConvert.SerializeObject(reqResult));
}
else
{
var result = new EdgeHubScopeResultError(HttpStatusCode.Unauthorized, authResult.ErrorMessage);
await this.SendResponse(result.Status, JsonConvert.SerializeObject(result));
}
}
internal static async Task <Try <string> > AuthorizeOnBehalfOf(
string actorDeviceId,
string authChain,
string source,
HttpContext httpContext,
IEdgeHub edgeHub,
IHttpRequestAuthenticator authenticator)
{
if (!AuthChainHelpers.TryGetTargetDeviceId(authChain, out string targetDeviceId))
{
Events.InvalidRequestAuthChain(source, authChain);
return(Try <string> .Failure(new ValidationException(HttpStatusCode.BadRequest, FormatErrorResponseMessage($"Invalid request auth chain {authChain}."))));
}
if (!await AuthenticateAsync(actorDeviceId, Option.Some(Constants.EdgeHubModuleId), Option.Some(authChain), httpContext, authenticator))
{
return(Try <string> .Failure(new ValidationException(HttpStatusCode.Unauthorized)));
}
IDeviceScopeIdentitiesCache identitiesCache = edgeHub.GetDeviceScopeIdentitiesCache();
Option <string> targetAuthChain = await identitiesCache.GetAuthChain(targetDeviceId);
return(targetAuthChain.Match(
ac =>
{
if (!AuthChainHelpers.ValidateAuthChain(actorDeviceId, targetDeviceId, ac))
{
Events.AuthorizationFail_InvalidAuthChain(actorDeviceId, targetDeviceId, ac);
return Try <string> .Failure(new ValidationException(HttpStatusCode.Unauthorized));
}
return ac;
},
() =>
{
Events.AuthorizationFail_NoAuthChain(targetDeviceId);
return Try <string> .Failure(new ValidationException(HttpStatusCode.Unauthorized));
}));
}
public async Task CreateOrUpdateModuleAsync(
[FromRoute] string deviceId,
[FromRoute] string moduleId,
[FromHeader(Name = "if-match")] string ifMatchHeader,
[FromBody] Module module)
{
try
{
Events.ReceivedRequest(nameof(this.CreateOrUpdateModuleAsync), deviceId, moduleId);
try
{
deviceId = WebUtility.UrlDecode(Preconditions.CheckNonWhiteSpace(deviceId, nameof(deviceId)));
moduleId = WebUtility.UrlDecode(Preconditions.CheckNonWhiteSpace(moduleId, nameof(moduleId)));
Preconditions.CheckNotNull(module, nameof(module));
if (!string.Equals(deviceId, module.DeviceId) || !string.Equals(moduleId, module.Id))
{
throw new ApplicationException("Device Id or module Id doesn't match between request URI and body.");
}
}
catch (Exception ex)
{
Events.BadRequest(nameof(this.CreateOrUpdateModuleAsync), ex.Message);
await this.SendResponseAsync(HttpStatusCode.BadRequest, FormatErrorResponseMessage(ex.Message));
return;
}
IHttpRequestAuthenticator authenticator = await this.authenticatorGetter;
if (!await AuthenticateAsync(deviceId, Option.None <string>(), Option.None <string>(), this.HttpContext, authenticator))
{
await this.SendResponseAsync(HttpStatusCode.Unauthorized);
return;
}
IEdgeHub edgeHub = await this.edgeHubGetter;
IDeviceScopeIdentitiesCache identitiesCache = edgeHub.GetDeviceScopeIdentitiesCache();
Option <string> targetAuthChain = await identitiesCache.GetAuthChain(deviceId);
if (!targetAuthChain.HasValue)
{
Events.AuthorizationFail_NoAuthChain(deviceId);
await this.SendResponseAsync(HttpStatusCode.Unauthorized);
return;
}
string edgeDeviceId = edgeHub.GetEdgeDeviceId();
var requestData = new CreateOrUpdateModuleOnBehalfOfData($"{targetAuthChain.OrDefault()}", module);
RegistryApiHttpResult result = await this.apiClient.PutModuleAsync(edgeDeviceId, requestData, ifMatchHeader);
await this.SendResponseAsync(result.StatusCode, result.JsonContent);
Events.CompleteRequest(nameof(this.CreateOrUpdateModuleAsync), edgeDeviceId, requestData.AuthChain, result);
}
catch (Exception ex)
{
Events.InternalServerError(nameof(this.CreateOrUpdateModuleAsync), ex);
await this.SendResponseAsync(HttpStatusCode.InternalServerError, FormatErrorResponseMessage(ex.ToString()));
}
}
public async Task ListModulesAsync(
[FromRoute] string deviceId)
{
try
{
Events.ReceivedRequest(nameof(this.ListModulesAsync), deviceId);
if (!this.HttpContext.Request.Query.ContainsKey("api-version"))
{
Dictionary <string, string> headers = new Dictionary <string, string>();
headers.Add("iothub-errorcode", "InvalidProtocolVersion");
await this.SendResponseAsync(HttpStatusCode.BadRequest, headers, string.Empty);
return;
}
try
{
deviceId = WebUtility.UrlDecode(Preconditions.CheckNonWhiteSpace(deviceId, nameof(deviceId)));
}
catch (Exception ex)
{
Events.BadRequest(nameof(this.ListModulesAsync), ex.Message);
await this.SendResponseAsync(HttpStatusCode.BadRequest, FormatErrorResponseMessage(ex.Message));
return;
}
IHttpRequestAuthenticator authenticator = await this.authenticatorGetter;
if (!await AuthenticateAsync(deviceId, Option.None <string>(), Option.None <string>(), this.HttpContext, authenticator))
{
await this.SendResponseAsync(HttpStatusCode.Unauthorized);
return;
}
IEdgeHub edgeHub = await this.edgeHubGetter;
IDeviceScopeIdentitiesCache identitiesCache = edgeHub.GetDeviceScopeIdentitiesCache();
Option <string> targetAuthChain = await identitiesCache.GetAuthChain(deviceId);
if (!targetAuthChain.HasValue)
{
Events.AuthorizationFail_NoAuthChain(deviceId);
await this.SendResponseAsync(HttpStatusCode.Unauthorized);
return;
}
string edgeDeviceId = edgeHub.GetEdgeDeviceId();
var requestData = new ListModulesOnBehalfOfData($"{targetAuthChain.OrDefault()}");
RegistryApiHttpResult result = await this.apiClient.ListModulesAsync(edgeDeviceId, requestData);
await this.SendResponseAsync(result.StatusCode, result.JsonContent);
Events.CompleteRequest(nameof(this.ListModulesAsync), edgeDeviceId, requestData.AuthChain, result);
}
catch (Exception ex)
{
Events.InternalServerError(nameof(this.ListModulesAsync), ex);
await this.SendResponseAsync(HttpStatusCode.InternalServerError, FormatErrorResponseMessage(ex.ToString()));
}
}
