// [DataRow(nameof(ProvisioningTransportHandlerMqtt), nameof(SecurityClientX509), X509EnrollmentType.Individual, TransportFallbackType.TcpOnly)]
// [DataRow(nameof(ProvisioningTransportHandlerMqtt), nameof(SecurityClientX509), X509EnrollmentType.Individual, TransportFallbackType.WebSocketOnly)]
public async Task ProvisioningDeviceClient_InvalidGlobalAddress_Register_Fail(
string transportType,
string securityType,
X509EnrollmentType?x509EnrollmentType,
TransportFallbackType?transportFallback)
{
using (ProvisioningTransportHandler transport = CreateTransportHandlerFromName(transportType, transportFallback))
using (SecurityClient security = CreateSecurityClientFromName(securityType, x509EnrollmentType))
{
ProvisioningDeviceClient provClient = ProvisioningDeviceClient.Create(
Configuration.Provisioning.IdScope,
security,
transport);
provClient.GlobalDeviceEndpoint = InvalidGlobalAddress;
var cts = new CancellationTokenSource(FailingTimeoutMiliseconds);
_log.WriteLine("ProvisioningClient RegisterAsync . . . ");
var exception = await Assert.ThrowsExceptionAsync <ProvisioningTransportException>(
() => provClient.RegisterAsync(cts.Token)).ConfigureAwait(false);
_log.WriteLine($"Exception: {exception}");
}
}
public void SetUp()
{
_testHelper = new SecurityClientTestHelper();
_securityClient = _testHelper.CreateSecurityClient();
_methodInformation = MockRepository.GenerateMock <IMethodInformation>();
_methodInformation.Expect(n => n.Name).Return("StaticMethod");
}
private void button1_Click(object sender, EventArgs e)
{
SecurityClient client = new SecurityClient("ISecuritySoap11");
LoginRequest loginRequest = new LoginRequest();
loginRequest.computerId = MainWindow.id;
loginRequest.login = this.textBox1.Text;
loginRequest.password = this.textBox2.Text;
try
{
LoginResponse response = client.Login(loginRequest);
MainWindow.Session = response.session;
}
catch (Exception ex)
{
this.label1.Text = "Wrong login or password";
return;
}
close = true;
// try
// {
// Process[] proc = Process.GetProcessesByName("winword");
// foreach (Process element in proc)
// {
// Console.WriteLine(proc.Length);
// element.Kill();
// }
// }
// catch (Exception ex)
// {
// }
msgBox.Close();
}
static void Main(string[] args)
{
LoggerFactory.Initialize();
_logger = LoggerFactory.GetLogger(typeof(Program));
if (args.Length != 2)
{
ShowUsage();
return;
}
int port;
if (!int.TryParse(args[1], out port))
{
ShowUsage();
return;
}
string machineName = args[0];
_logger.InfoFormat("Connecting server: '{0}'; port: '{1}'.", machineName, port);
using (SecurityClient client = new SecurityClient(machineName, port))
{
client.Connect();
//System.Console.ReadLine();
}
}
public static SecurityClient CreateSecurityClient(this CommerceClients source, string serviceUrl)
{
var connectionString = serviceUrl;
var subscriptionKey = ConfigurationManager.AppSettings["vc-marketplace-apikey"];
var client = new SecurityClient(new Uri(connectionString), new AzureSubscriptionMessageProcessingHandler(subscriptionKey, "secret"));
return client;
}
public static SecurityClient CreateSecurityClient(this CommerceClients source, string serviceUrl)
{
var client = new SecurityClient(
new Uri(serviceUrl),
source.CreateMessageProcessingHandler());
return client;
}
void SecurityWorker_DoWork(object sender, DoWorkEventArgs e)
{
SecurityClient SC = new SecurityClient();
e.Result = SC.HasPermissionToRun;
TurntableActivated = SC.IsModuleActivated("RotatingScanner");
}
static void Main(string[] args)
{
var sResult = string.Empty;
//var authClient = new AuthenticationServiceClient();
//var result = authClient.Login("admin", "admin111",string.Empty,true);
var secService = new SecurityClient();
//sResult = secService.SaveUser("283335746", "283335746", "*****@*****.**", true);
//sResult = secService.ValidateUser("admin", "admin111");
//secService.SaveRole("Administrator");
//sResult = secService.CreateRole("System");
//sResult = secService.DeleteRole("System", false);
//sResult = secService.RoleExists("Administrator");
//sResult = secService.GetAllRoles();
string[] usernames = { "admin", "283335746" };
string[] roleNames = { "Administrator" };
//sResult = secService.AddUsersToRoles(usernames, roleNames);
//sResult = secService.GetUsersInRole("Administrator");
//sResult = secService.IsUserInRole("admin", "Administrator");
sResult = secService.GetRolesForUser("admin");
}
public void SetUp()
{
_testHelper = NullSecurityClientTestHelper.CreateForStatefulSecurity();
_securityClient = _testHelper.CreateSecurityClient();
_methodInfo = typeof(SecurableObject).GetMethod("Show");
_methodInformation = MockRepository.GenerateStub <IMethodInformation>();
}
/// <summary>
/// Creates a PmpClient that will call the Pmp service
/// </summary>
/// <returns></returns>
internal static SecurityClient GetPmpClient()
{
SecurityClient client = new SecurityClient();
CredentialConfiguration wscredentials = (CredentialConfiguration)ConfigurationManager.GetSection("WsAuth");
client.SetCredentialStoreFromConfig(wscredentials);
return client;
}
private async Task <Client.IAuthenticationMethod> CreateAuthenticationMethodFromSecurityClient(
SecurityClient provisioningSecurity,
string deviceId,
string iotHub)
{
_verboseLog.WriteLine($"{nameof(CreateAuthenticationMethodFromSecurityClient)}({deviceId})");
if (provisioningSecurity is SecurityClientHsmTpm)
{
var security = (SecurityClientHsmTpm)provisioningSecurity;
var auth = new DeviceAuthenticationWithTpm(deviceId, security);
// TODO: workaround to populate Token.
await auth.GetTokenAsync(iotHub).ConfigureAwait(false);
return(auth);
}
else if (provisioningSecurity is SecurityClientHsmX509)
{
var security = (SecurityClientHsmX509)provisioningSecurity;
X509Certificate2 cert = security.GetAuthenticationCertificate();
return(new DeviceAuthenticationWithX509Certificate(deviceId, cert));
}
throw new NotSupportedException($"Unknown provisioningSecurity type.");
}
public static SecurityClient CreateSecurityClient(this CommerceClients source, string serviceUrl)
{
var client = new SecurityClient(
new Uri(serviceUrl),
source.CreateMessageProcessingHandler());
return(client);
}
private SecurityClient GetSecurityClient()
{
if (_securityClient == null)
{
_securityClient = SecurityClient.CreateSecurityClientFromConfiguration();
}
return(_securityClient);
}
static void Main(string[] args)
{
SecurityClient SC = new SecurityClient();
SC.Activate("asd");
Console.WriteLine(SC.HasPermissionToRun);
Console.ReadLine();
}
/// <summary>
/// Creates an instance of the Device Provisioning Client.
/// </summary>
/// <param name="globalDeviceEndpoint">The global device endpoint host-name.</param>
/// <param name="idScope">The IDScope for the Device Provisioning Service.</param>
/// <param name="securityClient">The security client instance.</param>
/// <param name="transport">The type of transport (e.g. HTTP, AMQP, MQTT).</param>
/// <returns>An instance of the DPSDeviceClient</returns>
public static ProvisioningDeviceClient Create(
string globalDeviceEndpoint,
string idScope,
SecurityClient securityClient,
TransportClient transport)
{
throw new System.NotImplementedException();
}
public void SetUp()
{
_testHelper = new SecurityClientTestHelper();
_securityClient = _testHelper.CreateSecurityClient();
_propertyInformation = MockRepository.GenerateMock <IPropertyInformation>();
_methodInformation = MockRepository.GenerateMock <IMethodInformation> ();
_propertyInformation.Expect(mock => mock.GetSetMethod(true)).Return(_methodInformation);
}
public async Task <IHttpActionResult> CreateApplication(SecurityClient client)
{
client.Secret = helper.GetHash(client.Secret);
SecurityManager.ClientCreate(client, "");
return(Ok());
}
public void SetUp()
{
_testHelper = new SecurityClientTestHelper();
_securityClient = _testHelper.CreateSecurityClient();
_methodInformation = MockRepository.GenerateMock <IMethodInformation> ();
_methodInformation.Expect(n => n.Name).Return("InstanceMethod");
_methodInfo = typeof(SecurableObject).GetMethod("IsValid", new[] { typeof(SecurableObject) });
}
public void SetUp()
{
_testHelper = new SecurityClientTestHelper();
_securityClient = _testHelper.CreateSecurityClient();
_methodInformation = MockRepository.GenerateMock <IMethodInformation>();
_propertyInfo = typeof(SecurableObject).GetProperty("IsVisible");
_methodInfo = _propertyInfo.GetGetMethod();
}
private IEnumerable <T> FilterByAccess <T> (IEnumerable <T> securableObjects, params Enum[] requiredAccessTypeEnums) where T : ISecurableObject
{
SecurityClient securityClient = SecurityClient.CreateSecurityClientFromConfiguration();
AccessType[] requiredAccessTypes = Array.ConvertAll(requiredAccessTypeEnums, AccessType.Get);
return(securableObjects.Where(o => securityClient.HasAccess(o, requiredAccessTypes)));
}
public void Create_WithNullSecurityProvider_ReturnsNullObject()
{
Assert.That(SecurityConfiguration.Current.DisableAccessChecks, Is.False);
_stubSecurityProvider.Stub(_ => _.IsNull).Return(true);
SecurityClient securityClient = SecurityClient.CreateSecurityClientFromConfiguration();
Assert.That(securityClient, Is.SameAs(SecurityClient.Null));
}
public void SetUp()
{
_testHelper = NullSecurityClientTestHelper.CreateForStatefulSecurity();
_securityClient = _testHelper.CreateSecurityClient();
_propertyInfo = typeof(SecurableObject).GetProperty("IsVisible");
_propertyInformation = MockRepository.GenerateStub <IPropertyInformation>();
_methodInformation = MockRepository.GenerateMock <IMethodInformation> ();
_propertyInformation.Expect(mock => mock.GetSetMethod(true)).Return(_methodInformation);
}
public ProvisioningTransportRegisterMessage(
string globalDeviceEndpoint,
string idScope,
SecurityClient security)
{
GlobalDeviceEndpoint = globalDeviceEndpoint;
IdScope = idScope;
Security = security;
}
private void btnPull_Click(object sender, EventArgs e)
{
string host = txtHost.Text.Trim();
string database = txtDatabase.Text.Trim();
string appKey = txtAppKey.Text.Trim();
string key = KeyBuilder.Build(host, database, appKey);
MessageBox.Show(SecurityClient.Get(key));
}
public IEnumerable <Substitution> GetActiveSubstitutions()
{
var securityClient = SecurityClient.CreateSecurityClientFromConfiguration();
if (!securityClient.HasAccess(this, AccessType.Get(GeneralAccessTypes.Read)))
{
return(new Substitution[0]);
}
return(SubstitutingFor.Where(s => s.IsActive));
}
/// <summary>
/// Resolves the hierarchy for the current <see cref="Group"/> as long as the user has <see cref="GeneralAccessTypes.Read"/> permissions
/// on the current object.
/// </summary>
private IEnumerable <Group> GetHierarchyWithSecurityCheck(Group startPoint)
{
var securityClient = SecurityClient.CreateSecurityClientFromConfiguration();
if (!securityClient.HasAccess(this, AccessType.Get(GeneralAccessTypes.Read)))
{
return(Enumerable.Empty <Group>());
}
return(new[] { this }.Concat(Children.SelectMany(c => c.GetHierarchyWithCircularReferenceCheck(startPoint))));
}
public async Task <ActionResult> Index(CredentialsModel model)//
{
// AssurBoxEnvironments.Test targets https://sandbox.assurbox.net
using (SecurityClient client = new SecurityClient(new AssurBoxClientOptions(AssurBoxEnvironments.Test)))
{
var token = await client.GetBearerToken(model.ClientID, model.ClientSecret);
SessionManager.BearerToken = token.access_token;
SessionManager.UserName = token.userName;
}
return(View());
}
/// <summary>
/// Creates an instance of the Device Provisioning Client.
/// </summary>
/// <param name="idScope">The IDScope for the Device Provisioning Service.</param>
/// <param name="securityClient">The security client instance.</param>
/// <param name="transport">The type of transport (e.g. HTTP, AMQP, MQTT).</param>
/// <returns>An instance of the ProvisioningDeviceClient</returns>
public static ProvisioningDeviceClient Create(
string idScope,
SecurityClient securityClient,
ProvisioningTransportHandler transport)
{
if (securityClient is SecurityClientHsmX509)
{
CertificateInstaller.EnsureChainIsInstalled(
((SecurityClientHsmX509)securityClient).GetAuthenticationCertificateChain());
}
return(new ProvisioningDeviceClient(DefaultGlobalDeviceEndpoint, idScope, securityClient, transport));
}
public void Create_WithEnabledAccessChecks_ReturnsSecurityClientWithMembersFromServiceLocator()
{
Assert.That(SecurityConfiguration.Current.DisableAccessChecks, Is.False);
SecurityClient securityClient = SecurityClient.CreateSecurityClientFromConfiguration();
Assert.IsInstanceOf(typeof(SecurityClient), securityClient);
Assert.That(securityClient.SecurityProvider, Is.SameAs(_stubSecurityProvider));
Assert.That(securityClient.PrincipalProvider, Is.SameAs(_stubPrincipalProvider));
Assert.That(securityClient.PermissionProvider, Is.SameAs(_stubPermissionProvider));
Assert.That(securityClient.MemberResolver, Is.SameAs(_stubMemberResolver));
Assert.That(securityClient.FunctionalSecurityStrategy, Is.SameAs(_stubFunctionalSecurityStrategy));
}
// methods and properties
public bool HasAccess(ISecurableObject securableObject, Delegate handler)
{
if (handler == null)
{
return(true);
}
if (SecurityFreeSection.IsActive)
{
return(true);
}
List <DemandTargetPermissionAttribute> attributes = GetPermissionAttributes(handler.GetInvocationList());
bool hasAccess = true;
foreach (DemandTargetPermissionAttribute attribute in attributes)
{
switch (attribute.PermissionSource)
{
case PermissionSource.WxeFunction:
hasAccess &= WxeFunction.HasAccess(attribute.FunctionType);
break;
case PermissionSource.SecurableObject:
SecurityClient securityClient = SecurityClient.CreateSecurityClientFromConfiguration();
if (securableObject == null)
{
hasAccess &= securityClient.HasStatelessMethodAccess(attribute.SecurableClass, attribute.MethodName);
}
else
{
hasAccess &= securityClient.HasMethodAccess(securableObject, attribute.MethodName);
}
break;
default:
throw new InvalidOperationException(string.Format(
"Value '{0}' is not supported by the PermissionSource property of the DemandTargetPermissionAttribute.",
attribute.PermissionSource));
}
if (!hasAccess)
{
break;
}
}
return(hasAccess);
}
// [DataRow(nameof(ProvisioningTransportHandlerAmqp), nameof(SecurityClientTpm), null, TransportFallbackType.WebSocketOnly)]
// [DataRow(nameof(ProvisioningTransportHandlerAmqp), nameof(SecurityClientX509), X509EnrollmentType.Individual, TransportFallbackType.WebSocketOnly)]
// [DataRow(nameof(ProvisioningTransportHandlerAmqp), nameof(SecurityClientX509), X509EnrollmentType.Group, TransportFallbackType.WebSocketOnly)]
// [DataRow(nameof(ProvisioningTransportHandlerMqtt), nameof(SecurityClientTpm), null, TransportFallbackType.TcpOnly)]
// [DataRow(nameof(ProvisioningTransportHandlerMqtt), nameof(SecurityClientX509), X509EnrollmentType.Individual, TransportFallbackType.TcpOnly)]
// [DataRow(nameof(ProvisioningTransportHandlerMqtt), nameof(SecurityClientX509), X509EnrollmentType.Group, TransportFallbackType.TcpOnly)]
// [DataRow(nameof(ProvisioningTransportHandlerMqtt), nameof(SecurityClientTpm), null, TransportFallbackType.WebSocketOnly)]
// [DataRow(nameof(ProvisioningTransportHandlerMqtt), nameof(SecurityClientX509), X509EnrollmentType.Individual, TransportFallbackType.WebSocketOnly)]
// [DataRow(nameof(ProvisioningTransportHandlerMqtt), nameof(SecurityClientX509), X509EnrollmentType.Group, TransportFallbackType.WebSocketOnly)]
public async Task ProvisioningDeviceClient_ValidRegistrationId_Register_Ok(
string transportType,
string securityType,
X509EnrollmentType?x509EnrollmentType,
TransportFallbackType?transportFallback)
{
if (string.IsNullOrWhiteSpace(Configuration.Provisioning.IdScope))
{
Assert.Inconclusive();
}
using (ProvisioningTransportHandler transport = CreateTransportHandlerFromName(transportType, transportFallback))
using (SecurityClient security = CreateSecurityClientFromName(securityType, x509EnrollmentType))
{
_verboseLog.WriteLine("Creating device");
ProvisioningDeviceClient provClient = ProvisioningDeviceClient.Create(
Configuration.Provisioning.IdScope,
security,
transport);
var cts = new CancellationTokenSource(PassingTimeoutMiliseconds);
_log.WriteLine("ProvisioningClient RegisterAsync . . . ");
DeviceRegistrationResult result = await provClient.RegisterAsync(cts.Token);
_log.WriteLine($"{result.Status}");
_log.WriteLine($"ProvisioningClient AssignedHub: {result.AssignedHub}; DeviceID: {result.DeviceId}");
Assert.AreEqual(ProvisioningRegistrationStatusType.Assigned, result.Status);
Assert.IsNotNull(result.AssignedHub);
Assert.IsNotNull(result.DeviceId);
Client.IAuthenticationMethod auth =
await CreateAuthenticationMethodFromSecurityClient(security, result.DeviceId, result.AssignedHub);
using (DeviceClient iotClient = DeviceClient.Create(result.AssignedHub, auth, Client.TransportType.Mqtt_Tcp_Only))
{
_log.WriteLine("DeviceClient OpenAsync.");
await iotClient.OpenAsync();
_log.WriteLine("DeviceClient SendEventAsync.");
await iotClient.SendEventAsync(new Client.Message(Encoding.UTF8.GetBytes("TestMessage")));
_log.WriteLine("DeviceClient CloseAsync.");
await iotClient.CloseAsync();
}
}
}
public SecurityClient Login(string email, string password)
{
IEnumerable <SecurityClient> securityClients = unitOfWork.SecurityClientRepository.Get((sc => sc.Email == email && sc.Password.Equals(password)));
if (securityClients.Count() > 0)
{
string token = Guid.NewGuid().ToString();
SecurityClient securityClient = securityClients.First();
securityClient.Token = token;
unitOfWork.Save();
return(securityClient);
}
return(null);
}
/// <summary>
/// Gets the JWT token to communicate with AssurBox
/// </summary>
/// <returns></returns>
public static string GetAssurBoxSecurityToken()
{
string token = MemoryCache.Default["ABX_TOKEN"] as string;
if (string.IsNullOrEmpty(token))
{
SecurityClient id = new SecurityClient(new AssurBoxClientOptions {
Host = Config.AssurBoxApiBaseURL
});
var tokeninfo = id.GetBearerToken(Config.AssurBoxApiClientID, Config.AssurBoxApiClientSecret).Result;
token = tokeninfo.access_token;
MemoryCache.Default["ABX_TOKEN"] = token;
}
return(token);
}
public HomeController(SecurityClient securityClient, AccountClient accountClient)
{
this.securityClient = securityClient;
this.accountClient = accountClient;
}
public static SecurityClient CreateSecurityClient(this CommerceClients source, string serviceUrl, string appId, string secretKey)
{
var client = new SecurityClient(new Uri(serviceUrl), appId, secretKey);
return client;
}
