public void WordStartingWithKeyIsNotRecognised()
{
var output = new KeyParser().ParseLine(0, "keytest", TokenType.Key).Single();
var expectedOutput = new ParsedSpan(0, TokenType.Parameter, 0, "keytest", Errors.Invalid);
AreEqual(expectedOutput, output);
}
public void GetDelimiterCount_ReturnsCorrectCount(string input, int expected)
{
var sut = new KeyParser();
var result = sut.GetDelimiterCount(input);
Assert.Equal(expected, result);
}
public void KeyWithTabIsRecognised()
{
var output = new KeyParser().ParseLine(0, " key\t ", TokenType.Key).Single();
var expectedOutput = new ParsedSpan(0, TokenType.Key, 1, "key", string.Format(Errors.ExpectsParam, "Key"));
AreEqual(expectedOutput, output);
}
public void NextTokenShouldBeData()
{
var parser = new KeyParser();
parser.ParseLine(0, "key", TokenType.Key).Single();
Assert.AreEqual(TokenType.Data | TokenType.Enum, parser.NextExpectedToken);
}
private void RunTestValid(TestGroupTest test)
{
ECPublicKeyParameters publicKey = KeyParser.ParsePublicKeyDer(Hex.Decode(test.PublicKey));
ECPrivateKeyParameters privateKey = KeyParser.ParsePrivateKeyHex(test.PrivateKey);
byte[] expectedSharedSecret = Hex.Decode(test.SharedSecret);
byte[] sharedSecret = KeyDerivation.ComputeSharedSecret(privateKey, publicKey);
Assert.True(sharedSecret.SequenceEqual(expectedSharedSecret));
}
public MainForm()
{
InitializeComponent();
var parser = new KeyParser();
logic = new MainLogic(this, parser);
calculator = new GraphicsCalculator();
}
public void Parse_two_line_edge_case_should_not_parse()
{
DISetup.SetupContainer();
var sb = new StringBuilder();
sb.AppendLine(@"create_envoys = { ");
sb.AppendLine(@"create_ship = { name = random graphical_culture = ""ehof_01"" design = ""NAME_Compound_Envoy"" } }");
var sb2 = new System.Text.StringBuilder();
sb2.AppendLine(@"create_envoys = {");
sb2.AppendLine(@" create_ship = {");
sb2.AppendLine(@" name = random");
sb2.AppendLine(@" graphical_culture = ""ehof_01""");
sb2.AppendLine(@" design = ""NAME_Compound_Envoy""");
sb2.AppendLine(@" }");
sb2.AppendLine(@"}");
var args = new ParserArgs()
{
ContentSHA = "sha",
ModDependencies = new List <string> {
"1"
},
File = "events\\fake.txt",
Lines = sb.ToString().Split(Environment.NewLine.ToCharArray(), StringSplitOptions.RemoveEmptyEntries),
ModName = "fake"
};
var parser = new KeyParser(new CodeParser(new Logger()), null);
var result = parser.Parse(args).ToList();
result.Should().NotBeNullOrEmpty();
result.Count().Should().Be(1);
for (int i = 0; i < 1; i++)
{
result[i].ContentSHA.Should().Be("sha");
result[i].Dependencies.First().Should().Be("1");
result[i].File.Should().Be("events\\fake.txt");
switch (i)
{
case 0:
result[i].Code.Trim().Should().Be(sb2.ToString().Trim());
result[i].Id.Should().Be("create_envoys");
result[i].ValueType.Should().Be(Common.ValueType.Object);
break;
default:
break;
}
result[i].ModName.Should().Be("fake");
result[i].Type.Should().Be("events\\txt");
}
}
private void RunTestInvalid(TestGroupTest test)
{
ECPrivateKeyParameters privateKey = KeyParser.ParsePrivateKeyHex(test.PrivateKey);
byte[] publicKeyBytes = Hex.Decode(test.PublicKey);
Assert.Throws <ArgumentException>(() =>
{
ECPublicKeyParameters publicKey = KeyParser.ParsePublicKeyDer(publicKeyBytes);
byte[] sharedSecret = KeyDerivation.ComputeSharedSecret(privateKey, publicKey);
});
}
public void KeyWithParamSeparatedByTabIsRecognised()
{
var output = new KeyParser().ParseLine(0, " key\tid ", TokenType.Key).ToList();
var expectedOutput = new List <ParsedSpan>
{
new ParsedSpan(0, TokenType.Key, 1, "key"),
new ParsedSpan(0, TokenType.Key | TokenType.Parameter, 5, "id")
};
AreEqual(expectedOutput, output);
}
private void ProcessRequest(InputRequest request)
{
var key = KeyParser.ToConsoleKey(request.KeyInput);
var login = request.Login;
var character = level.GetPlayer(login);
Console.WriteLine($"Receive {key.Key} {login}");
foreach (var subscriber in subscribers)
{
subscriber.ProcessInput(key, character);
}
}
public void KeyWithTwoVariables()
{
var output = new KeyParser().ParseLine(0, " key id id2", TokenType.Key).ToList();
var expectedOutput = new List <ParsedSpan>
{
new ParsedSpan(0, TokenType.Key, 2, "key"),
new ParsedSpan(0, TokenType.Parameter | TokenType.Key, 6, "id"),
new ParsedSpan(0, TokenType.Parameter | TokenType.Key, 9, "id2")
};
AreEqual(expectedOutput, output);
}
public void Parse_inline_edge_case_should_yield_results()
{
DISetup.SetupContainer();
var sb = new StringBuilder();
sb.AppendLine(@"entity = { name = ""ai_01_blue_sponsored_colonizer_entity"" clone = ""ai_01_blue_colonizer_entity"" }");
var sb2 = new StringBuilder();
sb2.AppendLine(@"entity = {");
sb2.AppendLine(@" name = ""ai_01_blue_sponsored_colonizer_entity""");
sb2.AppendLine(@" clone = ""ai_01_blue_colonizer_entity""");
sb2.AppendLine(@"}");
var args = new ParserArgs()
{
ContentSHA = "sha",
ModDependencies = new List <string> {
"1"
},
File = "events\\fake.txt",
Lines = sb.ToString().Split(Environment.NewLine.ToCharArray(), StringSplitOptions.RemoveEmptyEntries),
ModName = "fake"
};
var parser = new KeyParser(new CodeParser(new Logger()), null);
var result = parser.Parse(args).ToList();
result.Should().NotBeNullOrEmpty();
result.Count().Should().Be(1);
for (int i = 0; i < 1; i++)
{
result[i].ContentSHA.Should().Be("sha");
result[i].Dependencies.First().Should().Be("1");
result[i].File.Should().Be("events\\fake.txt");
switch (i)
{
case 0:
result[i].Code.Trim().Should().Be(sb2.ToString().Trim());
result[i].Id.Should().Be("ai_01_blue_sponsored_colonizer_entity");
result[i].ValueType.Should().Be(Common.ValueType.Object);
break;
default:
break;
}
result[i].ModName.Should().Be("fake");
result[i].Type.Should().Be("events\\txt");
}
}
public void DuplicateVariables()
{
var output = new KeyParser().ParseLine(0, "key id a id", TokenType.Key).ToList();
var expectedOutput = new List <ParsedSpan>
{
new ParsedSpan(0, TokenType.Key, 0, "key"),
new ParsedSpan(0, TokenType.Key | TokenType.Parameter, 4, "id"),
new ParsedSpan(0, TokenType.Key | TokenType.Parameter, 7, "a"),
new ParsedSpan(0, TokenType.Key | TokenType.Parameter, 9, "id", string.Format(Errors.DuplicateValue, "Key", "id"))
};
AreEqual(expectedOutput, output);
}
/// <summary>
/// Sends a player action by the network.
/// </summary>
public void MakeAction(AbstractPlayer player, ActionType actionType)
{
foreach (var targetLogin in serverInputService.Responses.Keys)
{
var response = new ServerResponse
{
Type = ResponseType.Action,
Login = player.Login,
KeyInput = KeyParser.FromActionTypeToKeyInput(actionType)
};
Console.WriteLine($"Sending {response.Type.ToString()} {response.KeyInput} to {targetLogin}");
serverInputService.Responses[targetLogin].Enqueue(response);
}
}
public string Validate()
{
if (StoragePath.IndexOfAny(Path.GetInvalidPathChars()) != -1)
{
return("Invalid storage path");
}
if (!KeyParser.Validate(AntiKeyProtection))
{
return("Invalid protected keys value");
}
return(string.Empty);
}
public void SendMixed(string sequence)
{
// TODO: modifiers in mixed mode send e.g. ^{a down}
var keys = KeyParser.ParseKeyStream(sequence);
foreach (var key in keys)
{
if (key != Keys.None)
{
Send(key);
}
}
}
public void TestDerive()
{
ECPrivateKeyParameters privateKey = KeyParser.ParsePrivateKeyDer("MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgCPSuFr4iSIaQprjjchHPyDu2NXFe0vDBoTpPkYaK9dehRANCAATnaFz/vQKuO90pxsINyVNWojabHfbx9qIJ6uD7Q7ZSxmtyo/Ez3/o2kDT8g0pIdyVIYktCsq65VoQIDWSh2Bdm");
string ephemeralPublicKey = "BPhVspn70Zj2Kkgu9t8+ApEuUWsI/zos5whGCQBlgOkuYagOis7qsrcbQrcprjvTZO3XOU+Qbcc28FSgsRtcgQE=";
var keyDerivation = new KeyDerivation(16, 16);
KeyDerivation.DerivedKeys keys = keyDerivation.Derive(privateKey, ephemeralPublicKey);
byte[] expectedSymmetricKey = Hex.Decode("59EDEC98018C6DD4CCAF1119AD247843");
byte[] expectedMacKey = Hex.Decode("D5F72946AAE92D54697A4FF305B6F9F4");
Assert.True(keys.SymmetricEncryptionKey.SequenceEqual(expectedSymmetricKey));
Assert.True(keys.MacKey.SequenceEqual(expectedMacKey));
}
public void Setup()
{
_parser = new KeyParser();
var sb = new StringBuilder();
for (var i = 0; i < Colons; i++)
{
sb.Append(Word).Append(':');
}
sb.Append(Word);
_input = sb.ToString();
}
public void CanParse_inline_edge_case_should_not_parse()
{
DISetup.SetupContainer();
var sb = new StringBuilder();
sb.AppendLine(@"create_envoys = { create_ship = { name = random graphical_culture = ""ehof_01"" design = ""NAME_Compound_Envoy"" } }");
var args = new CanParseArgs()
{
File = "common\\gamerules\\test.txt",
Lines = sb.ToString().Split(Environment.NewLine.ToCharArray(), StringSplitOptions.RemoveEmptyEntries),
};
var parser = new KeyParser(new CodeParser(new Logger()), null);
var result = parser.CanParse(args);
result.Should().BeFalse();
}
public void CanParse_inline_edge_case_should_parse()
{
DISetup.SetupContainer();
var sb = new StringBuilder();
sb.AppendLine(@"entity = { name = ""ai_01_blue_sponsored_colonizer_entity"" clone = ""ai_01_blue_colonizer_entity"" }");
var args = new CanParseArgs()
{
File = "common\\gamerules\\test.txt",
Lines = sb.ToString().Split(Environment.NewLine.ToCharArray(), StringSplitOptions.RemoveEmptyEntries),
};
var parser = new KeyParser(new CodeParser(new Logger()), null);
var result = parser.CanParse(args);
result.Should().BeTrue();
}
public void CanParse_should_be_false_then_true()
{
var sb = new StringBuilder();
sb.AppendLine(@"@test = 1");
sb.AppendLine(@"");
sb.AppendLine(@"namespace = dmm_mod");
sb.AppendLine(@"");
sb.AppendLine(@"country_event = {");
sb.AppendLine(@" id = dmm_mod.1");
sb.AppendLine(@" hide_window = yes");
sb.AppendLine(@" is_triggered_only = yes");
sb.AppendLine(@"");
sb.AppendLine(@" trigger = {");
sb.AppendLine(@" has_global_flag = dmm_mod_1");
sb.AppendLine(@" }");
sb.AppendLine(@"");
sb.AppendLine(@" after = {");
sb.AppendLine(@" remove_global_flag = dmm_mod_1_opened");
sb.AppendLine(@" }");
sb.AppendLine(@"");
sb.AppendLine(@" immediate = {");
sb.AppendLine(@" country_event = {");
sb.AppendLine(@" id = asl_options.1");
sb.AppendLine(@" }");
sb.AppendLine(@" }");
sb.AppendLine(@"}");
var args = new CanParseArgs()
{
File = "common\\gamerules\\test.txt",
Lines = new List <string> {
"test", "test2 = {}"
}
};
var parser = new KeyParser(new CodeParser(new Logger()), null);
parser.CanParse(args).Should().BeFalse();
args.File = "events\\test.txt";
args.Lines = sb.ToString().Split(Environment.NewLine.ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
parser.CanParse(args).Should().BeTrue();
}
static void Main()
{
var key = KeyParser.GetKeyString(FString.KEY_PATH);
Console.WriteLine("Key: " + key);
var l = TrafficParser
.GetTrafficList(
HttpGet.Get(
Url.SERVER_ID_TRAFFIC(7269),
FString.HTTPGET_HEADER_KEY,
key,
10000,
FString.USER_AGENT)
.ToJObject());
long countIn = 0;
long countOut = 0;
foreach (var i in l)
{
Console.WriteLine("==============================");
Console.WriteLine("Date: " + i.Date);
Console.WriteLine("In : " + i.In);
Console.WriteLine("Out : " + i.Out);
Console.WriteLine("EFR : " + 100.0 * i.EFR + "%");
countIn += i.In;
countOut += i.Out;
}
Console.WriteLine("==============================");
Console.WriteLine("Total In : " + countIn);
Console.WriteLine("Total Out: " + countOut);
Console.WriteLine("Avg. EFR : " + 100.0 * countOut / countIn + "%");
Console.WriteLine("==============================");
Console.WriteLine("Finished! Press any key to exit...");
Console.ReadKey();
}
public string Parse()
{
// Read the contents of the file, but ignore lines that start
// with a semi-colon (;) because those are comments in BlitzBASIC
var lines = File.ReadLines(_map)
.Where((line) => !line.StartsWith(";"))
.ToArray();
// Create the laundry list of parsers
var roomParser = new RoomParser();
var willyStartParser = new WillyStartParser();
var exitParser = new ExitParser();
var travelatorParser = new TravelatorParser();
var keyParser = new KeyParser();
var horiz = new HorizontalBaddiesParser();
var airParser = new AirParser();
roomParser.Parse(lines);
willyStartParser.Parse(lines);
travelatorParser.Parse(lines);
exitParser.Parse(lines);
keyParser.Parse(lines);
horiz.Parse(lines);
airParser.Parse(lines);
return(JsonUtil.MakeFrom(roomParser,
willyStartParser,
travelatorParser,
exitParser,
keyParser,
horiz,
airParser));
/*
* Each line:
* if it matches a marker; process the number of lines required for that section
*/
}
public override byte[] ProcessBlock(
byte[] @in,
int inOff,
int inLen)
{
if (ForEncryption)
{
if (KeyPairGenerator != null)
{
EphemeralKeyPair ephKeyPair = KeyPairGenerator.Generate();
PrivParam = ephKeyPair.GetKeyPair().Private;
V = ephKeyPair.GetEncodedPublicKey();
}
}
else
{
if (KeyParser != null)
{
MemoryStream bIn = new MemoryStream(@in, inOff, inLen)
{
Position = SecureHeadSize
};
try
{
PubParam = KeyParser.ReadKey(bIn);
}
catch (IOException e)
{
throw new InvalidCipherTextException("unable to recover ephemeral public key: " + e.Message, e);
}
catch (ArgumentException e)
{
throw new InvalidCipherTextException("unable to recover ephemeral public key: " + e.Message, e);
}
int encLength = (inLen - (int)(bIn.Length - bIn.Position));
V = Arrays.CopyOfRange(@in, inOff + SecureHeadSize, inOff + encLength);
}
}
// Compute the common value and convert to byte array.
Agree.Init(PrivParam);
BigInteger z = Agree.CalculateAgreement(PubParam);
byte[] bigZ = BigIntegers.AsUnsignedByteArray(Agree.GetFieldSize(), z);
try
{
// Initialise the KDF.
KdfParameters kdfParam = new KdfParameters(bigZ, null);
Kdf.Init(kdfParam);
if (ForEncryption)
{
return(EncryptBlock(@in, inOff, inLen));
}
else
{
byte[] temp = new byte[inLen - SecureHeadSize];
Array.Copy(@in, inOff + SecureHeadSize, temp, 0, temp.Length);
return(DecryptBlock(temp, inOff, temp.Length));
}
}
finally
{
Arrays.Fill(bigZ, 0);
}
}
public void Parse_should_yield_results()
{
DISetup.SetupContainer();
var sb = new StringBuilder();
sb.AppendLine(@"@test = 1");
sb.AppendLine(@"");
sb.AppendLine(@"namespace = dmm_mod");
sb.AppendLine(@"");
sb.AppendLine(@"country_event = {");
sb.AppendLine(@" id = dmm_mod.1");
sb.AppendLine(@" hide_window = yes");
sb.AppendLine(@" is_triggered_only = yes");
sb.AppendLine(@"");
sb.AppendLine(@" trigger = {");
sb.AppendLine(@" has_global_flag = dmm_mod_1");
sb.AppendLine(@" }");
sb.AppendLine(@"");
sb.AppendLine(@" after = {");
sb.AppendLine(@" remove_global_flag = dmm_mod_1_opened");
sb.AppendLine(@" }");
sb.AppendLine(@"");
sb.AppendLine(@" immediate = {");
sb.AppendLine(@" country_event = {");
sb.AppendLine(@" id = asl_options.1");
sb.AppendLine(@" }");
sb.AppendLine(@" }");
sb.AppendLine(@"}");
var sb2 = new StringBuilder();
sb2.AppendLine(@"country_event = {");
sb2.AppendLine(@" id = dmm_mod.1");
sb2.AppendLine(@" hide_window = yes");
sb2.AppendLine(@" is_triggered_only = yes");
sb2.AppendLine(@" trigger = {");
sb2.AppendLine(@" has_global_flag = dmm_mod_1");
sb2.AppendLine(@" }");
sb2.AppendLine(@" after = {");
sb2.AppendLine(@" remove_global_flag = dmm_mod_1_opened");
sb2.AppendLine(@" }");
sb2.AppendLine(@" immediate = {");
sb2.AppendLine(@" country_event = {");
sb2.AppendLine(@" id = asl_options.1");
sb2.AppendLine(@" }");
sb2.AppendLine(@" }");
sb2.AppendLine(@"}");
var args = new ParserArgs()
{
ContentSHA = "sha",
ModDependencies = new List <string> {
"1"
},
File = "events\\fake.txt",
Lines = sb.ToString().Split(Environment.NewLine.ToCharArray(), StringSplitOptions.RemoveEmptyEntries),
ModName = "fake"
};
var parser = new KeyParser(new CodeParser(new Logger()), null);
var result = parser.Parse(args).ToList();
result.Should().NotBeNullOrEmpty();
result.Count().Should().Be(3);
for (int i = 0; i < 3; i++)
{
result[i].ContentSHA.Should().Be("sha");
result[i].Dependencies.First().Should().Be("1");
result[i].File.Should().Be("events\\fake.txt");
switch (i)
{
case 0:
result[i].Code.Trim().Should().Be("@test = 1");
result[i].Id.Should().Be("@test");
result[i].ValueType.Should().Be(Common.ValueType.Variable);
break;
case 1:
result[i].Id.Should().Be("fake-namespace");
result[i].ValueType.Should().Be(Common.ValueType.Namespace);
break;
case 2:
result[i].Id.Should().Be("dmm_mod.1");
result[i].Code.Should().Be(sb2.ToString().Trim().ReplaceTabs());
result[i].ValueType.Should().Be(Common.ValueType.Object);
break;
default:
break;
}
result[i].ModName.Should().Be("fake");
result[i].Type.Should().Be("events\\txt");
}
}
public static HotkeyDefinition Parse(string sequence)
{
Keys keys = Keys.None, extra = Keys.None;
Options options = Options.None;
string typed = string.Empty;
#region Modifiers
sequence = sequence.Replace(Core.Keyword_ModifierAltGr, new string(new[] { Core.Keyword_ModifierCtrl, Core.Keyword_ModifierAlt }));
for (int i = 0; i < sequence.Length; i++)
{
switch (sequence[i])
{
case Core.Keyword_ModifierLeftPair:
i++;
if (i == sequence.Length)
{
throw new ArgumentException();
}
switch (sequence[i])
{
case Core.Keyword_ModifierWin: extra = Keys.LWin; break;
case Core.Keyword_ModifierAlt: extra = Keys.LMenu; break;
case Core.Keyword_ModifierCtrl: extra = Keys.LControlKey; break;
case Core.Keyword_ModifierShift: extra = Keys.LShiftKey; break;
default: throw new ArgumentException();
}
break;
case Core.Keyword_ModifierRightPair:
i++;
if (i == sequence.Length)
{
throw new ArgumentException();
}
switch (sequence[i])
{
case Core.Keyword_ModifierWin: extra = Keys.RWin; break;
case Core.Keyword_ModifierAlt: extra = Keys.RMenu; break;
case Core.Keyword_ModifierCtrl: extra = Keys.RControlKey; break;
case Core.Keyword_ModifierShift: extra = Keys.RShiftKey; break;
default: throw new ArgumentException();
}
break;
case Core.Keyword_ModifierWin: extra = Keys.LWin; break;
case Core.Keyword_ModifierAlt: keys |= Keys.Alt; break;
case Core.Keyword_ModifierCtrl: keys |= Keys.Control; break;
case Core.Keyword_ModifierShift: keys |= Keys.Shift; break;
case Core.Keyword_HotkeyIgnoreModifiers: options |= Options.IgnoreModifiers; break;
case Core.Keyword_HotkeyPassThrough: options |= Options.PassThrough; break;
case Core.Keyword_HotkeyNoRecurse: continue;
default:
if (i > 0)
{
sequence = sequence.Substring(i);
}
i = sequence.Length;
break;
}
}
#endregion
int z = sequence.IndexOf(Core.Keyword_HotkeyCombination);
if (z != -1)
{
z++;
if (z < sequence.Length)
{
string alt = sequence.Substring(z).Trim();
extra = KeyParser.ParseKey(alt);
if (alt.Length == 1)
{
typed = alt;
}
}
sequence = sequence.Substring(0, z - 1).Trim();
}
z = sequence.LastIndexOf(Core.Keyword_Up, StringComparison.OrdinalIgnoreCase);
if (z > 0 && char.IsWhiteSpace(sequence, z - 1))
{
sequence = sequence.Substring(0, z).Trim();
options |= Options.Up;
}
keys |= KeyParser.ParseKey(sequence);
if (typed.Length == 0 && sequence.Length == 1)
{
typed = sequence;
}
return(new HotkeyDefinition(keys, extra, options, null)
{
Typed = typed
});
}
