// Generating encoded app request using appname, appid, vendor
public static async Task <(uint, string)> GenerateEncodedAppRequestAsync()
{
Console.WriteLine("\nGenerating application authentication request");
var authReq = new AuthReq
{
AppContainer = true,
App = new AppExchangeInfo {
Id = ConsoleAppConstants.AppId, Scope = string.Empty, Name = ConsoleAppConstants.AppName, Vendor = ConsoleAppConstants.Vendor
},
Containers = new List <ContainerPermissions> {
new ContainerPermissions {
ContName = "_publicNames", Access = { Insert = true }
}
}
};
return(await Session.EncodeAuthReqAsync(authReq));
}
public async Task <ActionResult> Auth(AuthReq req)
{
Client.DefaultRequestHeaders.Clear();
Client.DefaultRequestHeaders.Add("SystemCode", req.SystemCode);
var result = await Client.RequestPasswordTokenAsync(new PasswordTokenRequest
{
Address = "http://localhost:32354/connect/token",
ClientId = "Api",
ClientSecret = "6CD30DB681204AFA85CEFF8F157FE28E",
UserName = req.Name,
Password = req.Password,
Scope = "Api offline_access"
}, CancellationToken.None);
SaveTokenToRedis($"{req.SystemCode}-{req.Name}", result);
return(Json(new JwtToken(result.AccessToken, result.RefreshToken)));
}
public override async Task <LevelPoints> HandleRequest(
AuthReq <CardGameInfos, LevelPoints> request,
CancellationToken cancellationToken = default)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var userId = request.UserId;
var info = request.Value.Info;
// add level
var list = info.Select(d => d.WordIdOpenCount.Select(d => d.Key).ToArray()).ToList();
var levels = await Context.CreateLevels(userId, list).ConfigureAwait(false);
return(await CalculateMetrics(userId, info, levels, cancellationToken).ConfigureAwait(false));
}
// Generating encoded app request using app name, appid, vendor
public static async Task <(uint, string)> GenerateEncodedAppRequestAsync()
{
Logger.Info("Generating application authentication request");
var authReq = new AuthReq
{
AppContainer = true,
App = new AppExchangeInfo
{
Id = Constants.AppId,
Scope = string.Empty,
Name = Constants.AppName,
Vendor = Constants.Vendor
},
Containers = new List <ContainerPermissions>()
};
return(await Session.EncodeAuthReqAsync(authReq));
}
public static async Task <(uint, string)> GenerateEncodedAppRequestAsync(string appId)
{
Console.WriteLine("Generating application authentication request");
var authReq = new AuthReq
{
AppContainer = true,
App = new AppExchangeInfo {
Id = appId, Scope = "", Name = "SAFE Console", Vendor = "MaidSafe.net Ltd"
},
Containers = new List <ContainerPermissions> {
new ContainerPermissions {
ContName = "_publicNames", Access = { Insert = true }
}
}
};
return(await Session.EncodeAuthReqAsync(authReq));
}
public static async Task <(uint, string)> GenerateEncodedAuthReqAsync()
{
// Create an AuthReq
var authReq = new AuthReq
{
AppContainer = true,
App = new AppExchangeInfo
{
Id = Constants.AppId,
Scope = string.Empty,
Name = Constants.AppName,
Vendor = Constants.Vendor
},
Containers = new List <ContainerPermissions>()
};
// Return encoded AuthReq
return(await Session.EncodeAuthReqAsync(authReq));
}
private async Task CreateDemoTodoApp()
{
AuthReq authReq = new AuthReq
{
AppContainer = true,
App = new AppExchangeInfo {
Id = AppId, Scope = string.Empty, Name = AppName, Vendor = "MaidSafe.net Ltd"
},
Containers = new List <ContainerPermissions> {
new ContainerPermissions {
ContName = "_publicNames", Access = { Insert = true, Update = true, Delete = true }
}
}
};
Debug.WriteLine($"Create Test App: {AppName} - {AppId}");
_session = await CreateTestAppAsync(authReq);
Debug.WriteLine($"App Created Successfully");
}
public async Task GetWordsAsync()
{
// arrange
await using InWordsDataContext context = InWordsDataContextFactory.Create();
await CreateTestContext(context);
WordSetWordsRequest requestData = new WordSetWordsRequest()
{
WordSetId = context.Games.First().GameId
};
var request = new AuthReq <WordSetWordsRequest, WordSetWordsReply>(requestData)
{
UserId = context.Users.First().UserId
};
// act
var reply = await new GetMarkedWordsHandler(context).Handle(request);
// assert
Assert.Equal(2, reply.Words.Count);
}
public override Task <GetLevelsReply> HandleRequest(
AuthReq <GetLevelsRequest, GetLevelsReply> request,
CancellationToken cancellationToken = default)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var requestData = request.Value;
int userId = request.UserId;
GetLevelsReply getLevelsReply = new GetLevelsReply();
// select levels
var levelsOfGame = Context.GameLevels.Where(l => l.GameId.Equals(requestData.WordSetId));
// join users score
var starredLevels = Context.GetStarredLevels(levelsOfGame, request.UserId);
getLevelsReply.Levels.AddRange(starredLevels);
return(Task.Run(() => { return getLevelsReply; }));
}
public async void Find_Existed_Account()
{
// arrange
int userId = 1;
await using InWordsDataContext context = InWordsDataContextFactory.Create();
await context.AddAccount(userId);
await context.SaveChangesAsync();
var request = new AuthReq <Empty, ProfileReply>(new Empty())
{
UserId = userId,
};
var handler = new GetCurrentProfile(context);
var result = await handler.Handle(request);
// assert
Assert.Equal(userId, result.UserId);
}
public override Task <ProfileReply> HandleRequest(
AuthReq <Empty, ProfileReply> request,
CancellationToken cancellationToken = default)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var userId = request.UserId;
var publicInfo = Context.GetProfile(u => u.UserId == userId).SingleOrDefault();
if (publicInfo == null)
{
request.StatusCode = StatusCode.NotFound;
request.Detail = Strings.GetDetailMessage(Locale.RuRu, DetailMessage.UserIdNotFound);
return(Task.Run(() => new ProfileReply()));
}
return(Task.Run(() => publicInfo));
}
public override async Task <AddWordsReply> HandleRequest(AuthReq <UpdateWordsRequest, AddWordsReply> request,
CancellationToken cancellationToken = default)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var userId = request.UserId;
var requestData = request.Value;
DeleteWordsRequest deleteRequestData = new DeleteWordsRequest();
deleteRequestData.Delete.AddRange(requestData.Update.Select(d => d.Delete));
AddWordsRequest addRequestData = new AddWordsRequest();
addRequestData.Words.AddRange(requestData.Update.Select(d => new AddWordRequest()
{
LocalId = d.LocalId,
WordForeign = d.WordForeign,
WordNative = d.WordNative
}));
var addWordsRequest = new AuthReq <AddWordsRequest, AddWordsReply>(addRequestData)
{
UserId = userId
};
var deleteRequest = new AuthReq <DeleteWordsRequest, Empty>(deleteRequestData)
{
UserId = userId
};
var addTask = await addWords.Handle(addWordsRequest, cancellationToken).ConfigureAwait(false);
var deleteTask = await deleteWords.Handle(deleteRequest, cancellationToken).ConfigureAwait(false);
return(addTask);
}
void auth()
{
AuthReq auth_req = new AuthReq();
auth_req.accessKey = accessKey;
auth_req.subId = sub_id;
auth_req.sign = Encryptor.GetHashSha256(accessKey, sub_id, accessSecret);
auth_req.subType = subType;
TransferPkg pkg = build_TransferPkg((int)CmdId.AuthReq, ProtoBufEncoder.SerializeToBytes(auth_req));
TransferPkg auth_res = send_and_recv(pkg);
if (auth_res == null)
{
_logger.Error("Authentication failed, received unexpected response, needed AuthRsp, received nothing.");
reconnect();
return;
}
//check if auth is successful
if (auth_res.cmdId == (int)CmdId.AuthRsp)
{
AuthRsp rsp = ProtoBufDecoder.DeserializeToObj <AuthRsp>(auth_res.data);
if (rsp.ack == 0)
{
_logger.Info("Authenticated successfully.");
//subscribe
sub();
}
else
{
throw new Exception("Authentication failed, auth info:" + auth_req.ToString());
}
}
else
{
_logger.Error("Authentication failed, received unexpected response, needed AuthRsp, received:" + auth_res.cmdId);
}
}
public static Task <Session> CreateTestApp()
{
var locator = GetRandomString(10);
var secret = GetRandomString(10);
var authReq = new AuthReq
{
App = new AppExchangeInfo
{
Id = GetRandomString(10),
Name = GetRandomString(5),
Scope = null,
Vendor = GetRandomString(5)
},
AppContainer = true,
AppPermissionTransferCoins = true,
AppPermissionGetBalance = true,
AppPermissionPerformMutations = true,
Containers = new List <ContainerPermissions>()
};
return(CreateTestApp(locator, secret, authReq));
}
public async void TrainingIds_Empty()
{
int userId = 1;
int otherId = 2;
await using InWordsDataContext context = InWordsDataContextFactory.Create();
await context.AddAccount(userId);
await context.AddAccount(otherId);
await context.SaveChangesAsync();
var requestObject = new AuthReq <Empty, TrainingIdsReply>(new Empty())
{
UserId = userId
};
var addWords = new GetTrainingIds(context);
TrainingIdsReply response = await addWords.HandleRequest(requestObject).ConfigureAwait(false);
Assert.Empty(response.UserWordPairs);
}
public async void ConfirmValidCode()
{
// arrange
int userId = 1;
int rightCode = 111111;
string newEmail = "*****@*****.**";
await using InWordsDataContext context = InWordsDataContextFactory.Create();
await context.AddAccount(userId);
context.EmailVerifies.Add(new EmailVerifies()
{
UserId = userId,
Code = rightCode,
Email = newEmail
});
await context.SaveChangesAsync();
Account account = context.Accounts.First();
// act
var requestObject =
new AuthReq <ConfirmEmailRequest, ConfirmEmailReply>(
new ConfirmEmailRequest()
{
Email = newEmail, Code = rightCode
})
{
UserId = account.AccountId
};
var registration = new ConfirmEmail(context);
var test = await registration.HandleRequest(requestObject).ConfigureAwait(false);
// assert
Assert.Equal(0, context.EmailVerifies.Count());
Assert.Equal(newEmail, test.Email);
Assert.Equal(newEmail, context.Accounts.First().Email);
}
public async void CustomGames_SaveOnce()
{
int userId = 1;
using InWordsDataContext context = InWordsDataContextFactory.Create();
await context.AddAccount(userId);
await context.SaveChangesAsync();
EstimateTraining handler = new EstimateTraining(context);
var payload = new TrainingDataRequest();
var training = new Training
{
AudioMetric = new AudioMetric(),
ClosedAudioCards2Metric = new ClosedAudioCardsTwoMetric()
};
training.AudioMetric.WordIdOpenCount.Add(1, 1);
training.AudioMetric.WordIdOpenCount.Add(2, 1);
training.AudioMetric.WordIdOpenCount.Add(3, 1);
training.ClosedAudioCards2Metric.WordIdOpenCount.Add(1, 1);
training.ClosedAudioCards2Metric.WordIdOpenCount.Add(2, 1);
training.ClosedAudioCards2Metric.WordIdOpenCount.Add(3, 1);
payload.Metrics.Add(training);
var request = new AuthReq <TrainingDataRequest, TrainingScoreReply>(payload);
var result = await handler.HandleRequest(request);
Assert.Single(context.Games);
Assert.Single(context.GameTags);
Assert.Equal(GameTags.CustomLevelsHistory, context.GameTags.First().Tags);
Assert.Single(context.GameLevels);
Assert.Single(context.Historylevels);
Assert.Empty(context.GameLevelWords); // Because words 1,2,3 is not not found
}
/// <summary>
/// Delete account by id if exist
/// </summary>
/// <param name="request"></param>
/// <param name="cancellationToken"></param>
/// <exception cref="ArgumentNullException">Account not found</exception>
/// <returns></returns>
public override async Task <Empty> HandleRequest(
AuthReq <DeleteAccountRequest, Empty> request,
CancellationToken cancellationToken = default)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var accountId = request.UserId;
Account account = await Context.Accounts.FindAsync(accountId).ConfigureAwait(false);
if (account == default)
{
request.StatusCode = StatusCode.NotFound;
}
else
{
Context.Remove(account);
await Context.SaveChangesAsync().ConfigureAwait(false);
}
return(new Empty());
}
public async void AddUserWordPair()
{
// arrange
int userId = 1;
int otherId = 2;
await using InWordsDataContext context = InWordsDataContextFactory.Create();
await context.AddAccount(userId);
await context.AddAccount(otherId);
await context.SaveChangesAsync();
AddWordsRequest addWordsRequest = new AddWordsRequest();
addWordsRequest.Words.Add(new AddWordRequest()
{
LocalId = 0, WordForeign = "0", WordNative = "0-0"
});
addWordsRequest.Words.Add(new AddWordRequest()
{
LocalId = 2, WordForeign = "2", WordNative = "2-2"
});
// act
var requestObject = new AuthReq <AddWordsRequest, AddWordsReply>(addWordsRequest)
{
UserId = userId
};
var addWords = new AddWords(context);
AddWordsReply response = await addWords.HandleRequest(requestObject).ConfigureAwait(false);
// assert
Assert.Equal(2, context.UserWordPairs.Count());
Assert.Equal(2, response.WordIds.Where(d => d.ServerId > 0).Count());
}
public async void ConfirmInValidCode()
{
// arrange
int userId = 1;
int rightCode = 111111;
int badCode = 222222;
string newEmail = "*****@*****.**";
await using InWordsDataContext context = InWordsDataContextFactory.Create();
await context.AddAccount(userId);
context.EmailVerifies.Add(new EmailVerifies()
{
UserId = userId,
Code = rightCode,
Email = newEmail
});
await context.SaveChangesAsync();
Account account = context.Accounts.First();
// act
var requestObject =
new AuthReq <ConfirmEmailRequest, ConfirmEmailReply>(
new ConfirmEmailRequest()
{
Email = newEmail, Code = badCode
})
{
UserId = account.AccountId
};
// assert
var registration = new ConfirmEmail(context);
await Assert.ThrowsAsync <ArgumentNullException>(() => registration.HandleRequest(requestObject));
}
public override async Task <TrainingIdsReply> HandleRequest(AuthReq <Empty, TrainingIdsReply> request,
CancellationToken cancellationToken = default)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var userId = request.UserId;
var value = request.Value;
var inRangeWords = await Context.UserWordPairs.TrainingWords(userId)
.Select(d => d.UserWordPairId)
.ToArrayAsync()
.ConfigureAwait(false);
TrainingIdsReply trainingIdsReply = new TrainingIdsReply();
if (inRangeWords != null)
{
trainingIdsReply.UserWordPairs.AddRange(inRangeWords);
}
return(trainingIdsReply);
}
private Task <LevelPoints> CalculateMetrics(int userId,
RepeatedField <CardGameInfos.Types.CardGameInfo> info,
int[] levels,
CancellationToken cancellationToken)
{
CardGameMetrics cardGameMetrics = new CardGameMetrics();
for (int i = 0; i < levels.Length; i++)
{
var cardGameMetric = new CardGameMetric()
{
GameLevelId = levels[i]
};
cardGameMetric.WordIdOpenCount.Add(info[i].WordIdOpenCount);
cardGameMetrics.Metrics.Add(cardGameMetric);
}
var estimateRequest = new AuthReq <CardGameMetrics, LevelPoints>(cardGameMetrics)
{
UserId = userId
};
return(estimateClassicCardGame.Handle(estimateRequest, cancellationToken));
}
public async Task ShareMDataAuthTest()
{
var locator = Utils.GetRandomString(10);
var secret = Utils.GetRandomString(20);
var typeTag = 150001;
var authReq = new AuthReq {
App = new AppExchangeInfo {
Id = "net.maidsafe.test", Name = "TestApp", Scope = null, Vendor = "MaidSafe.net Ltd."
},
AppContainer = true,
Containers = new List <ContainerPermissions>()
};
var session = await Utils.CreateTestApp(locator, secret, authReq);
var mdInfo = await session.MDataInfoActions.RandomPrivateAsync((ulong)typeTag);
var actKey = Utils.GetRandomData(10).ToList();
var actValue = Utils.GetRandomData(10).ToList();
using (var userSignKeyHandle = await session.Crypto.AppPubSignKeyAsync())
using (var permissionsHandle = await session.MDataPermissions.NewAsync()) {
var permissionSet = new PermissionSet {
Read = true, Insert = true, Delete = false, Update = false, ManagePermissions = false
};
await session.MDataPermissions.InsertAsync(permissionsHandle, userSignKeyHandle, permissionSet);
using (var entriesHandle = await session.MDataEntries.NewAsync()) {
var key = await session.MDataInfoActions.EncryptEntryKeyAsync(mdInfo, actKey);
var value = await session.MDataInfoActions.EncryptEntryKeyAsync(mdInfo, actValue);
await session.MDataEntries.InsertAsync(entriesHandle, key, value);
await session.MData.PutAsync(mdInfo, permissionsHandle, entriesHandle);
}
}
session.Dispose();
authReq.App = new AppExchangeInfo {
Id = "net.maidsafe.test.app", Name = "Test App", Scope = null, Vendor = "MaidSafe.net Ltd."
};
var msg = await Session.EncodeAuthReqAsync(authReq);
var authResponse = await Utils.AuthenticateAuthRequest(locator, secret, msg.Item2, true);
var authGranted = await Session.DecodeIpcMessageAsync(authResponse) as AuthIpcMsg;
Assert.That(authGranted, Is.Not.Null);
session = await Session.AppRegisteredAsync(authReq.App.Id, authGranted.AuthGranted);
var shareMdReq = new ShareMDataReq {
App = authReq.App,
MData = new List <ShareMData> {
new ShareMData {
Name = mdInfo.Name, TypeTag = mdInfo.TypeTag, Perms = new PermissionSet {
Read = true, Insert = true
}
}
}
};
var ipcMsg = await Session.EncodeShareMDataRequestAsync(shareMdReq);
var response = await Utils.AuthenticateShareMDataRequest(locator, secret, ipcMsg.Item2, true);
var responseMsg = await Session.DecodeIpcMessageAsync(response) as ShareMDataIpcMsg;
Assert.That(responseMsg, Is.Not.Null);
Assert.That(ipcMsg.Item1, Is.EqualTo(responseMsg.ReqId));
var keys = await session.MData.ListKeysAsync(mdInfo);
Assert.That(keys.Count, Is.EqualTo(1));
session.Dispose();
}
public async Task ConnectAsRegisteredAppTest()
{
var authReq = new AuthReq {
App = new AppExchangeInfo {
Id = "net.maidsafe.test", Name = "TestApp", Scope = null, Vendor = "MaidSafe.net Ltd."
},
AppContainer = true,
Containers = new List <ContainerPermissions>()
};
using (var session = await Utils.CreateTestApp(authReq)) {
using (await session.Crypto.AppPubSignKeyAsync()) { }
}
authReq.AppContainer = false;
using (var session = await Utils.CreateTestApp(authReq)) {
using (await session.Crypto.AppPubSignKeyAsync()) { }
}
authReq.Containers = null;
using (var session = await Utils.CreateTestApp(authReq)) {
using (await session.Crypto.AppPubSignKeyAsync()) { }
}
authReq.Containers = new List <ContainerPermissions> {
new ContainerPermissions {
ContName = "_public", Access = new PermissionSet {
Read = true
}
},
new ContainerPermissions {
ContName = "_videos",
Access = new PermissionSet {
Read = true, Insert = true, Delete = false, ManagePermissions = false, Update = false
}
},
new ContainerPermissions {
ContName = "_publicNames",
Access = new PermissionSet {
Read = true, Insert = true, Delete = false, ManagePermissions = false, Update = false
}
},
new ContainerPermissions {
ContName = "_documents",
Access = new PermissionSet {
Read = true, Insert = true, Delete = false, ManagePermissions = false, Update = false
}
},
new ContainerPermissions {
ContName = "_music",
Access = new PermissionSet {
Read = true, Insert = true, Delete = false, ManagePermissions = false, Update = false
}
}
// TODO - Enable once fixed in authenticator
// new ContainerPermissions()
// {
// ContName = "_pictures",
// Access = new PermissionSet() { Read = true, Insert = true, Delete = false, ManagePermissions = false, Update = false }
// }
};
using (var session = await Utils.CreateTestApp(authReq)) {
using (await session.Crypto.AppPubSignKeyAsync()) { }
}
var authRequest = await Session.EncodeAuthReqAsync(authReq);
var response = await Utils.AuthenticateAuthRequest(authRequest.Item2, false);
Assert.That(async() => await Session.DecodeIpcMessageAsync(response), Throws.TypeOf <IpcMsgException>());
authReq.Containers =
new List <ContainerPermissions> {
new ContainerPermissions {
ContName = "someConatiner", Access = new PermissionSet()
}
};
Assert.That(async() => await Utils.CreateTestApp(authReq), Throws.TypeOf <FfiException>());
authReq.App = new AppExchangeInfo {
Id = "", Name = "", Scope = "", Vendor = ""
};
Assert.That(async() => await Utils.CreateTestApp(authReq), Throws.TypeOf <FfiException>());
authReq.App = new AppExchangeInfo();
Assert.That(async() => await Utils.CreateTestApp(authReq), Throws.TypeOf <FfiException>());
}
/// <summary>
/// Initialise Authentication IPC request.
/// </summary>
/// <param name="reqId">Request Id.</param>
/// <param name="authReq">Authentication request.</param>
public AuthIpcReq(uint reqId, AuthReq authReq)
{
ReqId = reqId;
AuthReq = authReq;
}
public async Task AppConatinerTest()
{
var authReq = new AuthReq
{
App = new AppExchangeInfo
{
Id = Utils.GetRandomString(10), Name = Utils.GetRandomString(10), Vendor = Utils.GetRandomString(10)
},
AppContainer = true,
Containers = new List <ContainerPermissions>()
};
var session = await Utils.CreateTestApp(authReq);
var mDataInfo = await session.AccessContainer.GetMDataInfoAsync("apps/" + authReq.App.Id);
var perms = await session.MData.ListUserPermissionsAsync(mDataInfo, await session.Crypto.AppPubSignKeyAsync());
Assert.IsTrue(perms.Insert);
Assert.IsTrue(perms.Update);
Assert.IsTrue(perms.Delete);
Assert.IsTrue(perms.Read);
Assert.IsTrue(perms.ManagePermissions);
var keys = await session.MData.ListKeysAsync(mDataInfo);
Assert.AreEqual(0, keys.Count);
using (var entriesActionHandle = await session.MDataEntryActions.NewAsync())
{
var encKey = await session.MDataInfoActions.EncryptEntryKeyAsync(mDataInfo, Utils.GetRandomData(15).ToList());
var encVal = await session.MDataInfoActions.EncryptEntryKeyAsync(mDataInfo, Utils.GetRandomData(25).ToList());
await session.MDataEntryActions.InsertAsync(entriesActionHandle, encKey, encVal);
await session.MData.MutateEntriesAsync(mDataInfo, entriesActionHandle);
}
using (var entriesActionHandle = await session.MDataEntryActions.NewAsync())
using (var entryHandle = await session.MDataEntries.GetHandleAsync(mDataInfo))
{
keys = await session.MData.ListKeysAsync(mDataInfo);
var value = await session.MDataEntries.GetAsync(entryHandle, keys[0].Key);
await session.MDataEntryActions.UpdateAsync(
entriesActionHandle,
keys[0].Key,
Utils.GetRandomData(10).ToList(),
value.Item2 + 1);
await session.MData.MutateEntriesAsync(mDataInfo, entriesActionHandle);
}
using (var entriesActionHandle = await session.MDataEntryActions.NewAsync())
using (var entryHandle = await session.MDataEntries.GetHandleAsync(mDataInfo))
{
keys = await session.MData.ListKeysAsync(mDataInfo);
var value = await session.MDataEntries.GetAsync(entryHandle, keys[0].Key);
await session.MDataEntryActions.DeleteAsync(entriesActionHandle, keys[0].Key, value.Item2 + 1);
await session.MData.MutateEntriesAsync(mDataInfo, entriesActionHandle);
}
}
/// <summary>
/// Encodes an authentication request.
/// </summary>
/// <param name="authReq">Authentication Request.</param>
/// <returns>RequestId, Encoded authentication request.</returns>
public static Task <(uint, string)> EncodeAuthReqAsync(AuthReq authReq)
{
return(AppBindings.EncodeAuthReqAsync(ref authReq));
}
public static async Task <Session> CreateTestApp(string locator, string secret, AuthReq authReq)
{
var authenticator = await Authenticator.CreateAccountAsync(locator, secret, GetRandomString(5));
var(_, reqMsg) = await Session.EncodeAuthReqAsync(authReq);
var ipcReq = await authenticator.DecodeIpcMessageAsync(reqMsg);
Assert.That(ipcReq, Is.TypeOf <AuthIpcReq>());
var authIpcReq = ipcReq as AuthIpcReq;
var resMsg = await authenticator.EncodeAuthRespAsync(authIpcReq, true);
var ipcResponse = await Session.DecodeIpcMessageAsync(resMsg);
Assert.That(ipcResponse, Is.TypeOf <AuthIpcMsg>());
var authResponse = ipcResponse as AuthIpcMsg;
Assert.That(authResponse, Is.Not.Null);
authenticator.Dispose();
return(await Session.AppRegisteredAsync(authReq.App.Id, authResponse.AuthGranted));
}
public async Task SharedMutableData()
{
var locator = Utils.GetRandomString(10);
var secret = Utils.GetRandomString(10);
var authReq = new AuthReq
{
App = new AppExchangeInfo {
Id = "net.maidsafe.sample", Name = "Inbox", Scope = null, Vendor = "MaidSafe.net Ltd"
},
Containers = new List <ContainerPermissions>()
};
var session = await Utils.CreateTestApp(locator, secret, authReq);
var typeTag = 16000;
var mDataInfo = await session.MDataInfoActions.RandomPrivateAsync((ulong)typeTag);
using (var permissionsH = await session.MDataPermissions.NewAsync())
{
using (var appSignKeyH = await session.Crypto.AppPubSignKeyAsync())
{
var ownerPermission = new PermissionSet {
Insert = true, ManagePermissions = true, Read = true
};
await session.MDataPermissions.InsertAsync(permissionsH, appSignKeyH, ownerPermission);
var sharePermissions = new PermissionSet {
Insert = true
};
await session.MDataPermissions.InsertAsync(permissionsH, NativeHandle.EmptyMDataPermissions, sharePermissions);
await session.MData.PutAsync(mDataInfo, permissionsH, NativeHandle.EmptyMDataEntries);
}
}
using (var entriesHandle = await session.MDataEntryActions.NewAsync())
{
var key = await session.MDataInfoActions.EncryptEntryKeyAsync(mDataInfo, Utils.GetRandomData(10).ToList());
var value = await session.MDataInfoActions.EncryptEntryValueAsync(mDataInfo, Utils.GetRandomData(10).ToList());
await session.MDataEntryActions.InsertAsync(entriesHandle, key, value);
await session.MData.MutateEntriesAsync(mDataInfo, entriesHandle);
}
using (var entriesHandle = await session.MDataEntries.GetHandleAsync(mDataInfo))
{
var keys = await session.MData.ListKeysAsync(mDataInfo);
foreach (var key in keys)
{
var encKey = await session.MDataEntries.GetAsync(entriesHandle, key.Key);
await session.MDataInfoActions.DecryptAsync(mDataInfo, encKey.Item1);
}
}
session.Dispose();
authReq = new AuthReq
{
App = new AppExchangeInfo {
Id = "net.maidsafe.share.md", Name = "Share Chat", Vendor = "MaidSafe.net Ltd"
},
AppContainer = false,
Containers = new List <ContainerPermissions>()
};
var session2 = await Utils.CreateTestApp(authReq);
using (var entriesHandle = await session2.MDataEntryActions.NewAsync())
{
var key = await session2.MDataInfoActions.EncryptEntryKeyAsync(mDataInfo, Utils.GetRandomData(10).ToList());
var value = await session2.MDataInfoActions.EncryptEntryValueAsync(mDataInfo, Utils.GetRandomData(10).ToList());
await session2.MDataEntryActions.InsertAsync(entriesHandle, key, value);
await session2.MData.MutateEntriesAsync(mDataInfo, entriesHandle);
}
using (var entriesHandle = await session2.MDataEntries.GetHandleAsync(mDataInfo))
{
var entries = await session2.MData.ListEntriesAsync(entriesHandle);
foreach (var entry in entries)
{
await session2.MDataInfoActions.DecryptAsync(mDataInfo, entry.Key.Key);
}
}
using (var entryAction = await session2.MDataEntryActions.NewAsync())
using (var entriesHandle = await session2.MDataEntries.GetHandleAsync(mDataInfo))
{
var keys = await session2.MData.ListKeysAsync(mDataInfo);
foreach (var key in keys)
{
var encKey = await session2.MDataEntries.GetAsync(entriesHandle, key.Key);
await session2.MDataEntryActions.DeleteAsync(entryAction, key.Key, encKey.Item2);
}
Assert.That(
async() => { await session2.MData.MutateEntriesAsync(mDataInfo, entryAction); },
Throws.TypeOf <FfiException>());
}
session2.Dispose();
}
public async Task AddRemoveUserPermission()
{
var locator = Utils.GetRandomString(10);
var secret = Utils.GetRandomString(10);
var authReq = new AuthReq
{
App = new AppExchangeInfo {
Id = "net.maidsafe.mdata.permission", Name = "CMS", Vendor = "MaidSafe.net Ltd"
},
AppContainer = true,
Containers = new List <ContainerPermissions>()
};
var cmsApp = await Utils.CreateTestApp(locator, secret, authReq);
var mDataInfo = await Utils.PreparePublicDirectory(cmsApp);
authReq.App.Name = "Hosting";
authReq.App.Id = "net.maidsafe.mdata.host";
var ipcMsg = await Session.EncodeAuthReqAsync(authReq);
var response = await Utils.AuthenticateAuthRequest(locator, secret, ipcMsg.Item2, true);
var decodedResponse = await Session.DecodeIpcMessageAsync(response) as AuthIpcMsg;
Assert.NotNull(decodedResponse);
var hostingApp = await Session.AppRegisteredAsync(authReq.App.Id, decodedResponse.AuthGranted);
var ipcReq = await Session.EncodeShareMDataRequestAsync(
new ShareMDataReq
{
App = authReq.App,
MData = new List <ShareMData>
{
new ShareMData
{
Name = mDataInfo.Name,
TypeTag = mDataInfo.TypeTag,
Perms = new PermissionSet {
Insert = true, Read = true
}
}
}
});
await Utils.AuthenticateShareMDataRequest(locator, secret, ipcReq.Item2, true);
await hostingApp.AccessContainer.RefreshAccessInfoAsync();
using (var entryhandle = await hostingApp.MDataEntryActions.NewAsync())
{
await hostingApp.MDataEntryActions.InsertAsync(
entryhandle,
Encoding.UTF8.GetBytes("default.html").ToList(),
Encoding.UTF8.GetBytes("<html><body>Hello Default</body></html>").ToList());
await hostingApp.MData.MutateEntriesAsync(mDataInfo, entryhandle);
}
var version = await cmsApp.MData.GetVersionAsync(mDataInfo);
using (var permissionHandle = await cmsApp.MData.ListPermissionsAsync(mDataInfo))
{
var userPermissions = await cmsApp.MDataPermissions.ListAsync(permissionHandle);
Assert.That(await cmsApp.MDataPermissions.LenAsync(permissionHandle), Is.EqualTo(userPermissions.Count));
var userPermissionToDel = userPermissions.Find(userPerm => userPerm.Item2.ManagePermissions == false);
await cmsApp.MData.DelUserPermissionsAsync(mDataInfo, userPermissionToDel.Item1, version + 1);
userPermissions.ForEach(perm => perm.Item1.Dispose());
}
using (var entryHandle = await hostingApp.MDataEntryActions.NewAsync())
{
await hostingApp.MDataEntryActions.InsertAsync(
entryHandle,
Encoding.UTF8.GetBytes("home.html").ToList(),
Encoding.UTF8.GetBytes("<html><body>Hello Home!</body></html>").ToList());
Assert.That(
async() => { await hostingApp.MData.MutateEntriesAsync(mDataInfo, entryHandle); },
Throws.TypeOf <FfiException>());
}
cmsApp.Dispose();
hostingApp.Dispose();
}
