public TokenTableSet Generate()
{
var tableSet = new TokenTableSet();
var forwardTable = new TokenTable();
var reverseTable = new TokenTable();
var alphabet = string.IsNullOrWhiteSpace(_settings.CharacterString) ?
_settings.CharacterArray :
(_settings.CharacterString + (_settings.IncludeSpaces ? Characters.Space : string.Empty) + (_settings.IncludePunctuation ? Characters.Punctuation : string.Empty) + (_settings.IncludeSpecialCharacters ? Characters.SpecialCharacters : string.Empty)).ToCharArray().ToList();
if (alphabet.Count == 0)
{
throw new ArgumentException("A character set must be supplied.");
}
for (var i = 0; i < _settings.Size; i++)
{
GenerateRandomColumn(_settings.Size, alphabet, forwardTable, reverseTable);
}
tableSet.ForwardTable = forwardTable;
tableSet.ReverseTable = reverseTable;
return(tableSet);
}
public async Task <List <BasicResult> > TokenizeAsync(List <string> sources, TokenTableSet table)
{
var results = new ConcurrentBag <BasicResult>();
var tasks = new List <Task>();
foreach (var source in sources)
{
tasks.Add(TokenizeString(table, results, source));
}
await Task.WhenAll(tasks);
return(results.ToList());
}
public BasicResult Detokenize(BasicRequest request, TokenTableSet table)
{
try
{
return(DetokenizeAsync(new List <BasicRequest> {
request
}, table).Result[0]);
}
catch (Exception ex)
{
throw ex.InnerException;
}
}
public BasicResult Tokenize(string source, TokenTableSet table)
{
try
{
return(TokenizeAsync(new List <string> {
source
}, table).Result[0]);
}
catch (Exception ex)
{
throw ex.InnerException;
}
}
private async Task TokenizeString(TokenTableSet table, ConcurrentBag <BasicResult> results, string source)
{
var seeds = new List <int>();
var result = new BasicResult {
Value = source
};
result = await Task.Run(() => TokenizeCycle(table, seeds, result));
result.Action = ActionType.Tokenize;
result.SourceValue = source;
Encrypt(seeds, result);
results.Add(result);
}
public BasicClient(ITableGenerator tableGenerator, IBasicService basicService, ISerialisation serialisation, ICompression compression, IEncryption encryption, TokenTableSet tokenTableSet)
{
_tableGenerator = tableGenerator;
_basicService = basicService;
_serialisation = serialisation;
_compression = compression;
_encryption = encryption;
if (tokenTableSet == null)
{
_tokenTableSet = GenerateTokenTable();
}
else
{
_tokenTableSet = tokenTableSet;
}
}
private async Task DetokenizeString(TokenTableSet table, ConcurrentBag <BasicResult> results, BasicRequest request)
{
Decrypt(request);
if (request.Seed != null)
{
request.Seed.Reverse();
}
var result = new BasicResult {
Value = request.Source
};
result = await Task.Run(() => DetokeniseCycle(table, request, result));
result.Action = ActionType.Detokenize;
result.SourceValue = request.Source;
results.Add(result);
}
private BasicResult DetokeniseCycle(TokenTableSet table, BasicRequest request, BasicResult result)
{
var seed = -1;
if (_settings.Behaviour == Behaviour.RandomSeedInconsistent && !_settings.SeedPerCycle)
{
seed = request.Seed[0];
}
for (int i = 0; i < _settings.Cycles; i++)
{
if (_settings.Behaviour == Behaviour.RandomSeedInconsistent && _settings.SeedPerCycle)
{
seed = request.Seed[i];
}
result = Encode(result.Value, table.ReverseTable, seed);
}
return(result);
}
private BasicResult TokenizeCycle(TokenTableSet table, List <int> seeds, BasicResult result)
{
var currentSeed = -1;
if (_settings.Behaviour == Behaviour.RandomSeedInconsistent && !_settings.SeedPerCycle)
{
currentSeed = GetSeed(table.ForwardTable.Count);
seeds.Add(currentSeed);
}
for (int i = 0; i < _settings.Cycles; i++)
{
if (_settings.Behaviour == Behaviour.RandomSeedInconsistent && _settings.SeedPerCycle)
{
currentSeed = GetSeed(table.ForwardTable.Count);
seeds.Add(currentSeed);
}
result = Encode(result.Value, table.ForwardTable, currentSeed);
}
return(result);
}
public BasicClient(IGeneratorSettings generatorSettings, IServiceSettings serviceSettings, TokenTableSet tokenTableSet) : this(new TableGenerator(generatorSettings), new BasicService(serviceSettings, new Encryption(), new Compression()), new Serialisation(), new Compression(), new Encryption(), tokenTableSet)
{
}
public async Task <List <BasicResult> > DetokenizeAsync(List <BasicRequest> requests, TokenTableSet table)
{
var results = new ConcurrentBag <BasicResult>();
var tasks = new List <Task>();
foreach (var request in requests)
{
tasks.Add(DetokenizeString(table, results, request));
}
await Task.WhenAll(tasks);
return(results.ToList());
}
