private async Task <Certificate[]> IssueCertificates(string[] attributeKeys) { Certificate[] certificates = new Certificate[attributeKeys.Length]; int i = 0; foreach (string key in attributeKeys) { Attribute attr = SynAck.Id.Attributes[key]; Certificate cert = new Certificate() { OwningAttribute = attr, Revoked = false, Location = "CertFor" + attr.Description, Hash = "HashFor" + attr.Description }; await _certificateFacade.DeployAsync(cert); certificates[i] = cert; i++; } return(certificates); }
/// <summary> /// Get object T given the UID. /// </summary> /// <returns>The object T.</returns> /// <param name="UID">UID.</param> public override async Task <ID> GetAsync(int UID) { ID id = await base.GetAsync(UID); //if we have a non-empty collection of certificates, then we return //because it means that the Attribute was loaded from the identity //map if (id.Attributes.Count > 0) { return(id); } SQLiteConnection conn = await ConnectToTableAsync <IDAttribute>(); TableQuery <IDAttribute> query = null; await Task.Run(() => { query = conn .Table <IDAttribute>() .Where(mapping => mapping.IDUID == UID); }); foreach (IDAttribute mapping in query) { Attribute attr = await _attrMapper.GetAsync(mapping.AttrUID); id.AddAttribute(attr); } conn.Close(); return(id); }
public override void Setup() { base.Setup(); //create some dummy attributes Attribute firstname = new Attribute() { Location = "1", Hash = "1", Description = "firstname", Content = new StringContent("Olivier") }; Attribute lastname = new Attribute() { Location = "2", Hash = "2", Description = "lastname", Content = new StringContent("Brochu Dufour") }; Attribute[] AccessibleAttr = new Attribute[] { firstname, lastname }; IContent name = new StringContent("Olivier"); _payload.Add("name", JsonConvert.SerializeObject(name)); _token = new InfoRequestResponse(_header, _payload) { Id = _id, AccessibleAttributes = AccessibleAttr }; }
public override async Task TestGetAsync() { await base.TestGetAsync(); foreach (KeyValuePair <string, Attribute> kV in t.Attributes) { Assert.True(tRecovered.Attributes.ContainsKey(kV.Key)); Attribute newAttribute = tRecovered.GetAttribute(kV.Key); Attribute originalAttribute = kV.Value; Assert.AreEqual(originalAttribute.UID, newAttribute.UID); Assert.AreEqual(originalAttribute.Location, newAttribute.Location); Assert.AreEqual(originalAttribute.Hash, newAttribute.Hash); Assert.AreEqual(originalAttribute.Description, newAttribute.Description); Assert.AreEqual(originalAttribute.Content.ToString(), newAttribute.Content.ToString()); foreach (KeyValuePair <string, Certificate> kV2 in originalAttribute.Certificates) { Assert.True(newAttribute.Certificates.ContainsKey(kV2.Key)); Certificate newCertificate = newAttribute.Certificates[kV2.Key]; Certificate originalCertificate = kV2.Value; Assert.AreEqual(originalCertificate.UID, newCertificate.UID); Assert.AreEqual(originalCertificate.Hash, newCertificate.Hash); Assert.AreEqual(originalCertificate.Location, newCertificate.Location); Assert.AreEqual(originalCertificate.OwningAttribute.UID, newCertificate.OwningAttribute.UID); Assert.AreEqual(originalCertificate.Content.ToString(), newCertificate.Content.ToString()); } } }
public async Task <ID> DeployAsync(ID id) { FactoryService factory = new FactoryService(Web3, AccountService.PrivateKey, _factoryAddress); //Use the provided Factory address to create an ID + IDController Event idCreationEvent = factory.GetEventReturnIDController(); HexBigInteger filterAddressFrom = await idCreationEvent.CreateFilterAsync(AccountService.GetAccountAddress()); await factory.CreateIDAsync(); List <EventLog <ReturnIDControllerEventDTO> > log = await idCreationEvent.GetFilterChanges <ReturnIDControllerEventDTO>(filterAddressFrom); string controllerAddress = log[0].Event._controllerAddress; IDControllerService idcService = new IDControllerService(Web3, AccountService.PrivateKey, controllerAddress); id.ControllerAddress = controllerAddress; id.Address = await idcService.GetIDAsyncCall(); id.Owner = await idcService.OwnerAsyncCall(); //Add each attribute from the ID model to the ID smart contract foreach (string key in id.Attributes.Keys) { Attribute attribute = id.GetAttribute(key); await AddAttributeAsync(id, attribute); } return(id); }
private async Task <Attribute> GetAttributeByKey(IDControllerService idcService, byte[] attributeKey) { string ethAttributeAddress = await idcService.GetAttributeAsyncCall(attributeKey); //Get the attribute and add it to the dict Attribute attribute = await _attributeFacade.GetAttributeAsync(ethAttributeAddress); return(attribute); }
public override void Setup() { base.Setup(); ///////////////////// //Create a dummy ID// ///////////////////// //create some dummy attributes Attribute firstname = new Attribute() { Location = "1", Hash = "1", Content = new StringContent("Olivier"), Description = "firstname" }; Attribute lastname = new Attribute() { Location = "2", Hash = "2", Content = new StringContent("Brochu Dufour"), Description = "lastname" }; Attribute age = new Attribute() { Location = "3", Hash = "3", Content = new IntContent(24), Description = "age" }; _id = new ID(); _id.AddAttribute(firstname); _id.AddAttribute(lastname); _id.AddAttribute(age); ///////////////////////// //Create an eth account// ///////////////////////// _privateKey = "9e6a6bf412ce4e3a91a33c7c0f6d94b3127b8d4f5ed336210a672fe595bf1769"; _accountService = new AccountService(_privateKey); ////////////////////////////////////////////// //Add to the header and footers dictionaries// ////////////////////////////////////////////// _header.Add("pubkey", _accountService.PublicKey); _header.Add("encrypted", "False"); _payload.Add("idAddr", _id.Address); }
private async Task SeedID(IServiceProvider sp) { AccountService accountService = new AccountService("9e6a6bf412ce4e3a91a33c7c0f6d94b3127b8d4f5ed336210a672fe595bf1769"); IContentService contServ = sp.GetService <IContentService>(); ICertificateFacade certFacade = new CertificateFacade(sp.GetService <Web3>(), contServ, accountService); IAttributeFacade attrFacade = new AttributeFacade(sp.GetService <Web3>(), certFacade, contServ, accountService); IIDFacade idFacade = new IDFacade(StaticRessources.FactoryContractAddress, sp.GetService <Web3>(), attrFacade, accountService); //create some dummy attributes Attribute name = new Attribute() { Hash = "hash" + "Ephemeris", Location = "Location" + "Ephemeris", Content = new StringContent("Ephemeris"), Description = "name" }; Attribute address = new Attribute() { Location = "Location" + "2", Hash = "2", Content = new StringContent("31 rue des Pommmiers"), Description = "address" }; Attribute phone = new Attribute() { Location = "Location" + "3", Hash = "3", Content = new StringContent("555-555-5555"), Description = "phone" }; ID id = new ID(); id.AddAttribute(name); id.AddAttribute(address); id.AddAttribute(phone); try { id = await idFacade.DeployAsync(id); } catch (Exception e) { var o = e; } await sp.GetService <IMapper <ID> >().SaveAsync(id); }
public async Task <Certificate> AddCertificateAsync(Attribute attribute, Certificate cert) { //If the certificate is not deployed, deploy it if (cert.Address == null) { cert = await _certificateFacade.DeployAsync(cert); } //Add the certificate to the attribute AttributeService ethAttribute = new AttributeService(Web3, AccountService.PrivateKey, attribute.Address); await ethAttribute.AddCertificateAsync(cert.Address); return(cert); }
public async Task <Attribute> AddAttributeAsync(ID id, Attribute attribute) { IDControllerService idcService = new IDControllerService(Web3, AccountService.PrivateKey, id.ControllerAddress); //If the attribute to be added is not yet deployed, deploy it if (attribute.Address == null) { attribute = await _attributeFacade.DeployAsync(attribute, id.Address); } await idcService.AddAttributeAsync(attribute.Address); return(attribute); }
public async Task <Attribute> DeployAsync(Attribute attribute, string owner) { Bytes32TypeEncoder encoder = new Bytes32TypeEncoder(); string transactionHash = await AttributeService.DeployContractAsync(Web3, AccountService.PrivateKey, attribute.Location, encoder.Encode(attribute.Description), attribute.Hash, owner); TransactionReceipt receipt = await Web3.Eth.Transactions.GetTransactionReceipt.SendRequestAsync(transactionHash); //Populating the attribute model with the new address attribute.Address = receipt.ContractAddress; attribute.Owner = owner; //Iterating over certificates and deploying each one foreach (string key in attribute.Certificates.Keys) { Certificate cert = await _certificateFacade.DeployAsync(attribute.Certificates[key]); await AddCertificateAsync(attribute, cert); } return(attribute); }
public async Task <Dictionary <string, Attribute> > GetAttributesAsync(ID id) { IDControllerService idcService = new IDControllerService(Web3, AccountService.PrivateKey, id.ControllerAddress); Dictionary <string, Attribute> dict = new Dictionary <string, Attribute>(); BigInteger attributes = await idcService.AttributeCountAsyncCall(); for (BigInteger i = 0; i < attributes; i++) { //Get all attribute keys and addresses for the ID byte[] attributeKey = await idcService.GetAttributeKeyAsyncCall(i); //Get the attribute and add it to the dict Attribute newAttribute = await GetAttributeByKey(idcService, attributeKey); dict.Add(newAttribute.Description, newAttribute); } return(dict); }
public async Task <Dictionary <string, Certificate> > GetCertificatesAsync(Attribute attribute) { Dictionary <string, Certificate> certs = new Dictionary <string, Certificate>(); AttributeService ethAttribute = new AttributeService(Web3, AccountService.PrivateKey, attribute.Address); //Getting the number of certificates in the attribute BigInteger certCount = await ethAttribute.CertificateCountAsyncCall(); //Getting each certificate and adding it to the returned dictionary for (BigInteger i = new BigInteger(0); i < certCount; i++) { string certKey = await ethAttribute.CertificateKeysAsyncCall(i); string certAddress = await ethAttribute.CertificatesAsyncCall(certKey); Certificate cert = await _certificateFacade.GetCertificateAsync(certAddress); certs.Add(certKey, cert); } return(certs); }
/// <summary> /// JSON-Encodes and sends attributes and attribute contents to the requesting service /// </summary> public void AuthorizeReadRequest(string[] keysOfAttributesToAuthorize) { Attribute[] authorizedAttr = new Attribute[keysOfAttributesToAuthorize.Length]; for (int i = 0; i < keysOfAttributesToAuthorize.Length; i++) { authorizedAttr[i] = _id.Attributes[keysOfAttributesToAuthorize[i]]; } InfoRequestResponse response = new InfoRequestResponse() { Id = _id, PublicKey = _accountService.PublicKey, Encrypted = true, AccessibleAttributes = authorizedAttr }; byte[] requesterPubKey = Nethereum.Hex.HexConvertors.Extensions.HexByteConvertorExtensions.HexToByteArray(_infoRequestSynAck.PublicKey); _tokenCryptoService.Sign(response, _accountService.GetPrivateKeyAsByteArray()); string encryptedToken = _tokenCryptoService.Encrypt(response, requesterPubKey, _accountService.GetPrivateKeyAsByteArray()); _session.Send(encryptedToken); }
public async Task <Dictionary <string, Attribute> > GetAttributesAsync(ID id, string[] accessibleAttributes) { if (accessibleAttributes == null) { accessibleAttributes = new string[] { "firstname", "lastname", "cell", "address", "extra" } } ; foreach (string key in accessibleAttributes) { Attribute attr = new Attribute() { Address = "AddressOf" + key, Description = key, Location = "Location of " + key, Hash = "Hash of" + key, Content = new StringContent(key + " content") }; id.AddAttribute(attr); } return(id.Attributes); }
public async Task <Attribute> GetAttributeAsync(string address) { AttributeService ethAttribute = new AttributeService(Web3, AccountService.PrivateKey, address); byte[] descriptionArr = await ethAttribute.DescriptionAsyncCall(); string description = Encoding.UTF8.GetString(descriptionArr, 0, descriptionArr.Length); description = description.TrimEnd('\0');//remove null characters at the end of string //Populating attribute object with values from the smart contract Attribute attributeModel = new Attribute { Address = address, Hash = await ethAttribute.HashAsyncCall(), Location = await ethAttribute.LocationAsyncCall(), Owner = await ethAttribute.OwnerAsyncCall(), Description = description }; //Fetch the content of the attribute attributeModel.Content = _contentService.GetContent(attributeModel.Location, attributeModel.Hash); //Fetching each certificate and adding them to the attribute Dictionary <string, Certificate> certificates = await GetCertificatesAsync(attributeModel); foreach (Certificate cert in certificates.Values) { //replace the OwningAttribute placeholder with a complete instance cert.OwningAttribute = attributeModel; attributeModel.AddCertificate(cert); } return(attributeModel); }
public async Task <Dictionary <string, Attribute> > GetAttributesAsync(ID id, string[] accessibleAttributes) { IDControllerService idcService = new IDControllerService(Web3, AccountService.PrivateKey, id.ControllerAddress); Dictionary <string, Attribute> dict = new Dictionary <string, Attribute>(); BigInteger attributes = await idcService.AttributeCountAsyncCall(); for (BigInteger i = 0; i < attributes; i++) { //Get all attribute keys and addresses for the ID byte[] attributeKey = await idcService.GetAttributeKeyAsyncCall(i); string keyStr = Encoding.UTF8.GetString(attributeKey, 0, attributeKey.Length); keyStr = keyStr.TrimEnd('\0');//remove null characters at the end of string if (accessibleAttributes.Contains(keyStr)) { //Get the attribute and add it to the dict Attribute newAttribute = await GetAttributeByKey(idcService, attributeKey); dict.Add(newAttribute.Description, newAttribute); } } return(dict); }
public async void ViewCertificates(Attribute attrDTO) { await _navigationService.Navigate <CertificatesViewModel, Attribute>(ID.Attributes[attrDTO.Description]); }
public async Task <Attribute> DeployAsync(Attribute attribute, string owner) { throw new NotImplementedException(); }
public async Task <Dictionary <string, Certificate> > GetCertificatesAsync(Attribute attribute) { throw new NotImplementedException(); }
public virtual async Task Setup() { //create some dummy attributes Attribute firstname = new Attribute() { Location = "1", Hash = "1", Content = new StringContent("Olivier"), Description = "firstname" }; Certificate firstnameCert = new Certificate() { Hash = "hash", Location = "location", OwningAttribute = firstname, Content = new StringContent("content"), Owner = "0x123456778" }; firstname.AddCertificate(firstnameCert); Attribute lastname = new Attribute() { Location = "2", Hash = "2", Content = new StringContent("Brochu Dufour"), Description = "lastname" }; Certificate lastnameCert = new Certificate() { Hash = "hash2", Location = "location2", OwningAttribute = lastname, Content = new StringContent("content"), Owner = "0x123456778" }; lastname.AddCertificate(lastnameCert); Attribute age = new Attribute() { Location = "3", Hash = "3", Content = new IntContent(24), Description = "age" }; t = new ID(); t.AddAttribute(firstname); t.AddAttribute(lastname); t.AddAttribute(age); IFile file = await FileSystem.Current.LocalStorage.CreateFileAsync("mydata.db", CreationCollisionOption.ReplaceExisting); var path = file.Path; Mapper = new IDMapper(path, new AttributeMapper(path, new ExternalElementMapper <Certificate>(path))); Mapper2 = new IDMapper(path, new AttributeMapper(path, new ExternalElementMapper <Certificate>(path))); }
public void Setup() { ///////////////////// //Create a dummy ID// ///////////////////// //create some dummy attributes Attribute firstname = new Attribute() { Location = "1", Hash = "1", Content = new StringContent("Olivier"), Description = "firstname" }; Attribute lastname = new Attribute() { Location = "2", Hash = "2", Content = new StringContent("Brochu Dufour"), Description = "lastname" }; Attribute age = new Attribute() { Location = "3", Hash = "3", Content = new IntContent(24), Description = "age" }; Attribute cell = new Attribute() { Location = "4", Hash = "4", Content = new StringContent("555-555-5555"), Description = "cell" }; Attribute address = new Attribute() { Location = "5", Hash = "5", Content = new StringContent("1 infinite loop, cupertino"), Description = "address" }; _id = new ID(); _id.AddAttribute(firstname); _id.AddAttribute(lastname); _id.AddAttribute(age); _id.AddAttribute(cell); _id.AddAttribute(address); _id.Address = "0x1234567"; ///////////////////////// //Create an eth account// ///////////////////////// _privateKey = "9e6a6bf412ce4e3a91a33c7c0f6d94b3127b8d4f5ed336210a672fe595bf1769"; _accountService = new AccountService(_privateKey); //////////////////////// //Create the ID Facade// //////////////////////// initWeb3().Wait(); _certFacade = new CertificateFacade(_web3, new DummyContentService(), _accountService); _attributeFacade = new AttributeFacade(_web3, _certFacade, new DummyContentService(), _accountService); _idFacade = new IDFacade("0x0", _web3, _attributeFacade, _accountService); _tokenCryptoService = new TokenCryptoService <IToken>(new SECP256K1CryptoService()); _requester = new Requester(_tokenCryptoService, _accountService, _id, _idFacade, _attributeFacade, _certFacade); }
public Task <Attribute> AddAttributeAsync(ID id, Attribute attribute) { throw new NotImplementedException(); }
public async Task <Certificate> AddCertificateAsync(Attribute attribute, Certificate cert) { return(cert); }