public override void Serialize() { Data.SkipBytes(8); Data.ReadIntLE(); // unk Data.ReadShortLE(); // unk var PosY = Data.ReadShortLE(); Data.ReadShortLE(); // unk var PosX = Data.ReadShortLE(); // CONFIRMED CORRECT Data.SkipBytes(15); // unk stuff MoveType moveType = (MoveType)Data.ReadByte(); Data.ReadIntLE(); // unk zeros Data.ResetReaderIndex(); Logger.Debug($"\n{HexUtils.Dump(Data)}"); Logger.Debug($"X,Y[{PosX}, {PosY}] MoveType[{moveType.ToString()}]"); // DEBUG INFO /* * Logger.Debug( * $"\nPos1: {pos1}\n" + * $"Pos2: {pos2}\n" + * $"Pos3: {pos3}\n" + * $"PossibleZone: {possibleZone}\n" + * $"UnkFloatOrInt: {pos4}\n" + * $"IsMoving: {IsMoving}\n" * ); */ }
void EncodeDeclareByte(string hexBytes) { const int bitness = 64; const ulong newRip = 0x8000000000000000; var data = HexUtils.ToByteArray(hexBytes); var instructions = new Instruction[] { Instruction.Create(Code.Nopd), Instruction.CreateDeclareByte(data), Instruction.Create(Code.Nopd), }; var expectedData = new byte[data.Length + 2]; expectedData[0] = 0x90; Array.Copy(data, 0, expectedData, 1, data.Length); expectedData[expectedData.Length - 1] = 0x90; var codeWriter = new CodeWriterImpl(); bool b = BlockEncoder.TryEncode(bitness, new InstructionBlock(codeWriter, instructions, newRip), out var errorMessage, out var result); Assert.True(b); Assert.Null(errorMessage); Assert.Equal(expectedData, codeWriter.ToArray()); Assert.Equal(newRip, result.RIP); Assert.Null(result.RelocInfos); Assert.NotNull(result.NewInstructionOffsets); Assert.True(result.NewInstructionOffsets.Length == 0); Assert.NotNull(result.ConstantOffsets); Assert.True(result.ConstantOffsets.Length == 0); }
protected void NonDecodeEncodeBase(int codeSize, ref Instruction instr, string hexBytes, ulong rip) { var expectedBytes = HexUtils.ToByteArray(hexBytes); var writer = new CodeWriterImpl(); var encoder = Encoder.Create(codeSize, writer); Assert.Equal(codeSize, encoder.Bitness); var origInstrCopy = instr; bool result = encoder.TryEncode(instr, rip, out uint encodedInstrLen, out string errorMessage); Assert.True(errorMessage is null, "Unexpected ErrorMessage: " + errorMessage); Assert.True(result, "Error, result from Encoder.TryEncode must be true"); var encodedBytes = writer.ToArray(); Assert.Equal(encodedBytes.Length, (int)encodedInstrLen); Assert.True(Instruction.TEST_BitByBitEquals(instr, origInstrCopy)); if (!ArrayEquals(expectedBytes, encodedBytes)) { #pragma warning disable xUnit2006 // Do not use invalid string equality check // Show the full string without ellipses by using Equal<string>() instead of Equal() Assert.Equal <string>(ToString(expectedBytes), ToString(encodedBytes)); throw new InvalidOperationException(); #pragma warning restore xUnit2006 // Do not use invalid string equality check } }
public void ZoomMod() { // 0 to 3 over 3 steps // No range, no modifier int mod = HexUtils.DecayingModifier(0, -3, 3, 0.0f); Assert.AreEqual(0, mod); // Range just under step count of 3 * 30 = 89.9 mod = HexUtils.DecayingModifier(0, -3, 3, 89.9f); Assert.AreEqual(0, mod); // Range at first step count mod = HexUtils.DecayingModifier(0, -3, 3, 90.0f); Assert.AreEqual(-1, mod); // Range at second step count mod = HexUtils.DecayingModifier(0, -3, 3, 180.0f); Assert.AreEqual(-2, mod); // Range at third step count mod = HexUtils.DecayingModifier(0, -3, 3, 270.0f); Assert.AreEqual(-3, mod); // Range at fourth step count mod = HexUtils.DecayingModifier(0, -3, 3, 360.0f); Assert.AreEqual(-3, mod); }
protected void EncodeInvalidBase(int codeSize, Code code, string hexBytes, int invalidCodeSize) { var origBytes = HexUtils.ToByteArray(hexBytes); var decoder = CreateDecoder(codeSize, origBytes); var origRip = decoder.InstructionPointer; var origInstr = decoder.Decode(); Assert.Equal(code, origInstr.Code); Assert.Equal(origBytes.Length, origInstr.ByteLength); Assert.True(origInstr.ByteLength <= Iced.Intel.DecoderConstants.MaxInstructionLength); Assert.Equal((ushort)origRip, origInstr.IP16); Assert.Equal((uint)origRip, origInstr.IP32); Assert.Equal(origRip, origInstr.IP64); var afterRip = decoder.InstructionPointer; Assert.Equal((ushort)afterRip, origInstr.NextIP16); Assert.Equal((uint)afterRip, origInstr.NextIP32); Assert.Equal(afterRip, origInstr.NextIP64); var writer = new CodeWriterImpl(); var encoder = CreateEncoder(invalidCodeSize, writer); var origInstrCopy = origInstr; int encodedInstrLen = encoder.Encode(ref origInstr, origRip, out string errorMessage); Assert.True(errorMessage == Encoder.ERROR_ONLY_1632_BIT_MODE || errorMessage == Encoder.ERROR_ONLY_64_BIT_MODE); Assert.True(Instruction.TEST_BitByBitEquals(ref origInstr, ref origInstrCopy)); Assert.True(encodedInstrLen >= 0); }
public static RegSETrackPoint FromByteArray(byte[] buffer, int offset) { //* 16 Byte Blocke //* Byte 0-1: little endian 16bit, flags: 1=TRACK_START, 2=WAYPOINT,4=OVER_SPEED //* Byte 2-5: little endian 32bit: timestamp //* Byte 6-9: little endian 32bit: lattitude in Grad, wenn man es durch 10000000 dividiert //* Byte 10-13: little endian 32bit: longitude in Grad, wenn man es durch 10000000 dividiert //* Byte 14-15: little endian 16bit: altitude var type = HexUtils.ToInt16LE(buffer, offset + 0); var timeCode = HexUtils.ToInt32LE(buffer, offset + 2); int sec = (((timeCode) >> 0) & 0x3F); int min = (((timeCode) >> 6) & 0x3F); int hours = (((timeCode) >> 12) & 0x1F); int day = (((timeCode) >> 17) & 0x1F); int month = (((timeCode) >> 22) & 0x0F); int year = (((timeCode) >> 26) & 0x3F); var time = new DateTime(2000 + year, month, day, hours, min, sec); var latitudeValue = HexUtils.ToInt32LE(buffer, offset + 6); var longitudeValue = HexUtils.ToInt32LE(buffer, offset + 10); var altitude = HexUtils.ToInt16LE(buffer, offset + 14); var latitude = new Decimal(latitudeValue) / new Decimal(10000000); var longitude = new Decimal(longitudeValue) / new Decimal(10000000); return(new RegSETrackPoint(time, latitude, longitude, altitude, type)); }
public void HarkonnenMod() { int initialMod = 0, finalMod = 5, hexSteps = 2; int mod = HexUtils.DecayingModifier(initialMod, finalMod, hexSteps, 0f); Assert.AreEqual(0, mod); mod = HexUtils.DecayingModifier(initialMod, finalMod, hexSteps, 60f); Assert.AreEqual(1, mod); mod = HexUtils.DecayingModifier(initialMod, finalMod, hexSteps, 120f); Assert.AreEqual(2, mod); mod = HexUtils.DecayingModifier(initialMod, finalMod, hexSteps, 180f); Assert.AreEqual(3, mod); mod = HexUtils.DecayingModifier(initialMod, finalMod, hexSteps, 240f); Assert.AreEqual(4, mod); mod = HexUtils.DecayingModifier(initialMod, finalMod, hexSteps, 300f); Assert.AreEqual(5, mod); mod = HexUtils.DecayingModifier(initialMod, finalMod, hexSteps, 360f); Assert.AreEqual(5, mod); mod = HexUtils.DecayingModifier(initialMod, finalMod, hexSteps, 500f); Assert.AreEqual(5, mod); }
private static float GetVisualRange(float visionRange, AbstractActor source) { float visualRange; if (source.IsShutDown) { visualRange = visionRange * source.Combat.Constants.Visibility.ShutdownSpottingDistanceMultiplier; } else if (source.IsProne) { visualRange = visionRange * source.Combat.Constants.Visibility.ProneSpottingDistanceMultiplier; } else { float multipliers = VisualLockHelper.GetAllSpotterMultipliers(source); float absolutes = VisualLockHelper.GetAllSpotterAbsolutes(source); visualRange = visionRange * multipliers + absolutes; //Mod.Log.Trace?.Write($" -- source:{CombatantUtils.Label(source)} has spotting " + // $"multi:x{multipliers} absolutes:{absolutes} visionRange:{visionRange}"); } if (visualRange < Mod.Config.Vision.MinimumVisionRange()) { visualRange = Mod.Config.Vision.MinimumVisionRange(); } // Round up to the nearest full hex float normalizedRange = HexUtils.CountHexes(visualRange, false) * 30f; //LowVisibility.Logger.Trace($" -- source:{CombatantUtils.Label(source)} visual range is:{normalizedRange}m normalized from:{visualRange}m"); return(normalizedRange); }
// WARNING: DUPLICATE OF HBS CODE. THIS IS LIKELY TO BREAK IF HBS CHANGES THE SOURCE FUNCTIONS public static float GetAdjustedSpotterRange(AbstractActor source, ICombatant target) { float targetVisibility = 1f; AbstractActor targetActor = target as AbstractActor; if (targetActor != null) { EWState sourceState = source.GetEWState(); targetVisibility = VisualLockHelper.GetTargetVisibility(targetActor, sourceState); } float spotterRange = VisualLockHelper.GetSpotterRange(source); float modifiedRange = spotterRange * targetVisibility; if (modifiedRange < Mod.Config.Vision.MinimumVisionRange()) { modifiedRange = Mod.Config.Vision.MinimumVisionRange(); } // Round up to the nearest full hex float normalizedRange = HexUtils.CountHexes(modifiedRange, true) * 30f; Mod.Log.Trace?.Write($" -- source:{CombatantUtils.Label(source)} adjusted spotterRange:{normalizedRange}m normalized from:{modifiedRange}m"); return(normalizedRange); }
public void CreateResources(ICanvasResourceCreator resourceCreator) { DestroyResources(); // define path var pb = new CanvasPathBuilder(resourceCreator); var radiusH = HexUtils.GetRadiusHeight(Radius); pb.BeginFigure(-1 * Radius * HexUtils.COS60, radiusH); pb.AddLine(Radius * HexUtils.COS60, radiusH); pb.AddLine(Radius, 0); pb.AddLine(Radius * HexUtils.COS60, -1 * radiusH); pb.AddLine(-1 * Radius * HexUtils.COS60, -1 * radiusH); pb.AddLine(-1 * Radius, 0); pb.EndFigure(CanvasFigureLoop.Closed); // create and cache _strokeStyle = new CanvasStrokeStyle(); var geo = CanvasGeometry.CreatePath(pb); if (Filled) { _geo = CanvasCachedGeometry.CreateFill(geo); } else { _geo = CanvasCachedGeometry.CreateStroke(geo, Style.StrokeWidth, _strokeStyle); } }
/// <summary> /// Creates a coinbase transaction and adds it the block. /// </summary> /// <returns>The created coinbase transaction.</returns> /// <remarks> /// Since coinbase transaction must be the first transaction in a block, /// this method will throw an exception if the block already contains more than 0 transactions. /// </remarks> public Transaction AddCoinbaseTx(string address, long feeInNekoshi) { if (Transactions.Count > 0) { throw new System.InvalidOperationException("Coinbase must be the first transaction."); } long reward = Config.CalculateRewardInNekoshi(Index); var txIn = new TxIn { TxId = HexUtils.HexFromInt(Index), TxOutIndex = 0, Signature = "", }; var txOut = new TxOut { AmountInNekoshi = reward + feeInNekoshi, Address = address, }; var tx = new Transaction(); tx.Inputs.Add(txIn); tx.Outputs.Add(txOut); tx.Id = tx.GetId(); Transactions.Add(tx); return(tx); }
private void Update() { // TODO: Use a better source of pointer input than Input.mousePosition. var viewportPosition = Input.mousePosition; viewportPosition.z = _camera.transform.position.y; var worldPosition = _camera.ScreenToWorldPoint(viewportPosition); // Snap the cursor display to the cell the mouse is over. _cursorGridPosition = HexUtils.WorldToGrid(new Vector2(worldPosition.x, worldPosition.z)); worldPosition = HexUtils.GridToWorld(_cursorGridPosition); _cursor.transform.position = new Vector3(worldPosition.x, 0f, worldPosition.y); // TODO: Use a better source of input than Input. It would be nice to // use the EventSystem, but it's not clear how use it when clicking on // empty space. if (Input.GetMouseButtonDown(0) && _selectedDrone != null) { var command = new MoveToPosition { Target = _cursorGridPosition, }; AddCommandToQueue(CommandType.MoveToPosition, JsonUtility.ToJson(command), 5); } }
/// <summary> /// Collects all empty tiles in the given direction. /// Adds to the workingSet variable. /// </summary> /// <param name="workingSet">The set into which tiles should be added.</param> private void getTileLine(Player owningPlayer, HashSet <Tile> workingSet, HexUtils.hexDir dir, int dist) { if (this.associatedPlayer == null && dist > 0) { workingSet.Add(this); bool adjacentToEnemy = false; Tile[] neighbors = this.getNeighbors(); for (int i = 0; i < neighbors.Length; i++) { if (neighbors[i] != null && neighbors[i].associatedPlayer != null && neighbors[i].associatedPlayer != owningPlayer) { adjacentToEnemy = true; } } Tile tle = board.getTile(HexUtils.getIndexForDirection(this.gridLocation, dir)); if (tle != null && !adjacentToEnemy) { board.getTile(HexUtils.getIndexForDirection(this.gridLocation, dir)).getTileLine(owningPlayer, workingSet, dir, dist - 1); } } }
/// <summary> /// Attempts to mine the block with the next range of nonce values. /// </summary> /// <returns>True if the block is successfully mined.</returns> public bool Attempt() { int nonceRange = int.MaxValue - _startingNonce; if (nonceRange > _nonceRange) { nonceRange = _nonceRange; } for (int n = _startingNonce, c = _startingNonce + nonceRange; n < c; ++n) { HexUtils.AppendHexFromInt(_headerStreamWriter, n); _headerStreamWriter.Flush(); var hash = Pow.Hash(_headerStream); if (Pow.IsValidHash(hash, _difficulty)) { Block.Nonce = n; Block.Hash = HexUtils.HexFromByteArray(hash); return(true); } _headerStream.Seek(_streamOrgPosition, SeekOrigin.Begin); } _startingNonce += nonceRange; if (_startingNonce == int.MaxValue) { _maxNonceReached = true; } return(false); }
void CreateTest(int bitness, string hexBytes, Func<Instruction> create) { var bytes = HexUtils.ToByteArray(hexBytes); var decoder = Decoder.Create(bitness, new ByteArrayCodeReader(bytes)); switch (bitness) { case 16: decoder.InstructionPointer = DecoderConstants.DEFAULT_IP16; break; case 32: decoder.InstructionPointer = DecoderConstants.DEFAULT_IP32; break; case 64: decoder.InstructionPointer = DecoderConstants.DEFAULT_IP64; break; default: throw new InvalidOperationException(); } var origRip = decoder.InstructionPointer; decoder.Decode(out var decodedInstr); decodedInstr.CodeSize = 0; decodedInstr.ByteLength = 0; decodedInstr.NextIP64 = 0; var createdInstr = create(); Assert.True(Instruction.TEST_BitByBitEquals(ref decodedInstr, ref createdInstr)); var writer = new CodeWriterImpl(); var encoder = decoder.CreateEncoder(writer); bool result = encoder.TryEncode(ref createdInstr, origRip, out _, out var errorMessage); Assert.Null(errorMessage); Assert.True(result); Assert.Equal(bytes, writer.ToArray()); }
public JObject GetChildrenByHash(string nodeHash) { IHashTrieNode?node = _nodeRetrieval.TryGetNode(HexUtils.HexToBytes(nodeHash), out var childrenHash); if (node == null) { return new JObject { } } ; JArray children = new JArray { }; foreach (var childHash in childrenHash) { JObject child = GetNodeByHash(Web3DataFormatUtils.Web3Data(childHash)); if (child.Count == 0) { return new JObject { } } ; children.Add(child); } JObject nodeHashWithChildren = new JObject { }; nodeHashWithChildren[Web3DataFormatUtils.Web3Data(node.Hash)] = children; return(nodeHashWithChildren); }
public ZoomVision(int mod, int cap, int decay) { this.AttackMod = mod; this.AttackCap = cap; this.HexesUntilDecay = decay; this.MaximumRange = HexUtils.HexesInRange(mod, cap, decay) * 30; }
/// <summary> /// Counts the number of triples (3 mutually adjacent units) by "scrubbing over every unit in the group with two kernels." /// The two 'kernels' simply search for an up or down triangle with the unit in question being the left most unit. /// </summary> private void CountTriples() { this.numTriples = 0; foreach (Tile t in this.tiles) { // Find neighbor to the right Tile rNghbr = t.board.getTile(HexUtils.getIndexForDirection(t.gridLocation, HexUtils.hexDir.Right)); if (rNghbr != null && rNghbr.associatedPlayer == t.associatedPlayer) { // Find the neigbor up and to the right Tile ruNghbr = t.board.getTile(HexUtils.getIndexForDirection(t.gridLocation, HexUtils.hexDir.UpRight)); if (ruNghbr != null && ruNghbr.associatedPlayer == t.associatedPlayer) { this.numTriples++; } // Find the neigbor down and to the right Tile rdNghbr = t.board.getTile(HexUtils.getIndexForDirection(t.gridLocation, HexUtils.hexDir.DownRight)); if (rdNghbr != null && rdNghbr.associatedPlayer == t.associatedPlayer) { this.numTriples++; } } } }
public void LAMod2() { int initialMod = -4, finalMod = 0, hexSteps = 4; // No range, no modifier int mod = HexUtils.DecayingModifier(initialMod, finalMod, hexSteps, 0f); Assert.AreEqual(-4, mod); // Not full step, no modifier mod = HexUtils.DecayingModifier(initialMod, finalMod, hexSteps, 110f); Assert.AreEqual(-4, mod); // One step mod = HexUtils.DecayingModifier(initialMod, finalMod, hexSteps, 125f); Assert.AreEqual(-3, mod); // Two steps mod = HexUtils.DecayingModifier(initialMod, finalMod, hexSteps, 245f); Assert.AreEqual(-2, mod); // Three steps mod = HexUtils.DecayingModifier(initialMod, finalMod, hexSteps, 365f); Assert.AreEqual(-1, mod); // Four steps, same modifier mod = HexUtils.DecayingModifier(initialMod, finalMod, hexSteps, 485f); Assert.AreEqual(-0, mod); // Five steps, same modifier mod = HexUtils.DecayingModifier(initialMod, finalMod, hexSteps, 610f); Assert.AreEqual(0, mod); }
public float XZPositionToHeight(float x, float z, bool scaleByMapHeight = false) { Vector2 mapPoint = new Vector2(x, z) / tileSize * mapScale; return(HexUtils.GetHeightOnNoiseMap(noiseMap, mapPoint) * (scaleByMapHeight ? mapHeight : 1)); }
public void SniperMod() { // +3 to -3 over 6 steps // No range, full modifier int mod = HexUtils.DecayingModifier(3, -3, 2, 0.0f); Assert.AreEqual(3, mod); // First step (2*1*30), worse mod mod = HexUtils.DecayingModifier(3, -3, 2, 60.0f); Assert.AreEqual(2, mod); // Third step (2*3*30), neutral mod = HexUtils.DecayingModifier(3, -3, 2, 180.0f); Assert.AreEqual(0, mod); // Fourth step (2*4*30), positive mod = HexUtils.DecayingModifier(3, -3, 2, 240.0f); Assert.AreEqual(-1, mod); // Sixth step (2*6*30), positive mod = HexUtils.DecayingModifier(3, -3, 2, 360.0f); Assert.AreEqual(-3, mod); // Seventh step (2*7*30), capped mod = HexUtils.DecayingModifier(3, -3, 2, 420.0f); Assert.AreEqual(-3, mod); }
public void CreateOption(int index) { var uiChooseTile = UIManager.Singleton.UIChoosingTile; HexTile hexTile = null; if (index == 0) { hexTile = HexUtils.BuildHexTile(_hexTile.Data, Player.MyPlayer, HexTileRole.InUI); } else { var affordAble = false; var counter = 0; HexTileData randomData = null; while (!affordAble) { randomData = HexUtils.CreateRandomData(_hexTile.Data.X, _hexTile.Data.Y); counter++; if (counter == 100) { randomData = _hexTile.Data; UnityEngine.Debug.LogWarning("Could not find Random Data"); } affordAble = Player.MyPlayer.HasResource(HexUtils.CalcHexPrice(randomData)); } hexTile = HexUtils.BuildHexTile(randomData, Player.MyPlayer, HexTileRole.InUI); } hexTile.transform.SetParent(uiChooseTile.ChoosingTransforms[index].transform, false); hexTile.OnClickCallback = OnTileChosen; }
public static EntityTemplate Drone(AxialCoordinate position, string playerId) { // Calculate the world position based off the grid position. var worldPosition = HexUtils.GridToWorld(position); var entityTemplate = new EntityTemplate(); entityTemplate.AddComponent( new Drone.Snapshot { Owner = playerId, CommandQueue = new List <Command>() }, WorkerUtils.UnityGameLogic); entityTemplate.AddComponent( new Position.Snapshot(new Coordinates { X = worldPosition.x, Z = worldPosition.y }), WorkerUtils.UnityGameLogic); entityTemplate.AddComponent( new PlayerInventory.Snapshot(0, 0), WorkerUtils.UnityGameLogic); entityTemplate.AddComponent(new Metadata.Snapshot("Drone"), WorkerUtils.UnityGameLogic); entityTemplate.AddComponent(new Persistence.Snapshot(), WorkerUtils.UnityGameLogic); entityTemplate.SetReadAccess(WorkerUtils.AllWorkers); entityTemplate.SetComponentWriteAccess(EntityAcl.ComponentId, WorkerUtils.UnityGameLogic); return(entityTemplate); }
/** * Sends the provided data to the XBee device of the network corresponding * to the given 16-bit address. * * <p>This method blocks until a success or error response arrives or the * configured receive timeout expires.</p> * * <p>The received timeout is configured using the {@code setReceiveTimeout} * method and can be consulted with {@code getReceiveTimeout} method.</p> * * <p>For non-blocking operations use the method * {@link #sendData(XBee16BitAddress, byte[])}.</p> * * @param address The 16-bit address of the XBee that will receive the data. * @param data Byte array containing data to be sent. * * @throws InterfaceNotOpenException if the device is not open. * @throws ArgumentNullException if {@code address == null} or * if {@code data == null}. * @throws TimeoutException if there is a timeout sending the data. * @throws XBeeException if there is any other XBee related exception. * * @see com.digi.xbee.api.models.XBee16BitAddress * @see XBeeDevice#getReceiveTimeout() * @see XBeeDevice#setReceiveTimeout(int) * @see #sendData(RemoteXBeeDevice, byte[]) * @see #sendData(XBee64BitAddress, byte[]) * @see #sendDataAsync(RemoteXBeeDevice, byte[]) * @see #sendDataAsync(XBee16BitAddress, byte[]) * @see #sendDataAsync(XBee64BitAddress, byte[]) */ public void SendData(XBee16BitAddress address, byte[] data) /*throws TimeoutException, XBeeException */ { // Verify the parameters are not null, if they are null, throw an exception. if (address == null) { throw new ArgumentNullException("Address cannot be null"); } if (data == null) { throw new ArgumentNullException("Data cannot be null"); } // Check connection. if (!connectionInterface.SerialPort.IsOpen) { throw new InterfaceNotOpenException(); } // Check if device is remote. if (IsRemote) { throw new OperationNotSupportedException("Cannot send data to a remote device from a remote device."); } logger.InfoFormat(ToString() + "Sending data to {0} >> {1}.", address, HexUtils.PrettyHexString(data)); XBeePacket xbeePacket = new TX16Packet(GetNextFrameID(), address, (byte)XBeeTransmitOptions.NONE, data); SendAndCheckXBeePacket(xbeePacket, false); }
public void Can_Encrypt_And_Decrypt_Forms_Authentication_Ticket() { // These would come from the asp.net 3.5 applications <machineKey decryption="AES" decryptionKey"" validation="SHA1" validationKey="" /> web.config. // I have made these up for the purposes of this test. string validationKey = "30101052676849B0B494466B7A99656346328E8964748448E422D7344467A45777D972414947271744423422851D6742C9A09A65212C276C7F839157501291C6"; string decryptionKey = "AC7387D7E54B156377D81930CF237888854B5B5B515CF2D6356541255E696144"; // Arrange var issueDate = DateTime.Now; var expiryDate = issueDate.AddHours(1); var formsAuthenticationTicket = new FormsAuthenticationTicket(2, "*****@*****.**", issueDate, expiryDate, false, "custom data", "/"); byte[] decryptionKeyBytes = HexUtils.HexToBinary(decryptionKey); byte[] validationKeyBytes = HexUtils.HexToBinary(validationKey); var legacyFormsAuthenticationTicketEncryptor = new LegacyFormsAuthenticationTicketEncryptor(decryptionKeyBytes, validationKeyBytes); // Act // We encrypt the forms auth cookie. var encryptedText = legacyFormsAuthenticationTicketEncryptor.Encrypt(formsAuthenticationTicket); Assert.IsNotNull(encryptedText); // We decrypt the encypted text back into a forms auth ticket, and compare it to the original ticket to make sure it // roundtripped successfully. FormsAuthenticationTicket decryptedFormsAuthenticationTicket = legacyFormsAuthenticationTicketEncryptor.DecryptCookie(encryptedText); Assert.AreEqual(formsAuthenticationTicket.CookiePath, decryptedFormsAuthenticationTicket.CookiePath); Assert.AreEqual(formsAuthenticationTicket.Expiration, decryptedFormsAuthenticationTicket.Expiration); Assert.AreEqual(formsAuthenticationTicket.Expired, decryptedFormsAuthenticationTicket.Expired); Assert.AreEqual(formsAuthenticationTicket.IsPersistent, decryptedFormsAuthenticationTicket.IsPersistent); Assert.AreEqual(formsAuthenticationTicket.IssueDate, decryptedFormsAuthenticationTicket.IssueDate); Assert.AreEqual(formsAuthenticationTicket.UserData, decryptedFormsAuthenticationTicket.UserData); Assert.AreEqual(formsAuthenticationTicket.Version, decryptedFormsAuthenticationTicket.Version); }
static OptionsInstructionInfo?ReadTestCase(string line, int lineNo) { var parts = line.Split(seps); if (parts.Length != 4) { throw new InvalidOperationException($"Invalid number of commas ({parts.Length - 1} commas)"); } int bitness = NumberConverter.ToInt32(parts[0].Trim()); var hexBytes = parts[1].Trim(); HexUtils.ToByteArray(hexBytes); var codeStr = parts[2].Trim(); if (CodeUtils.IsIgnored(codeStr)) { return(null); } var code = ToCode(codeStr); var properties = new List <(OptionsProps property, object value)>(); foreach (var part in parts[3].Split(optsseps, StringSplitOptions.RemoveEmptyEntries)) { properties.Add(OptionsParser.ParseOption(part)); } return(new OptionsInstructionInfo(bitness, hexBytes, code, properties)); }
public static byte[] StringToBytesBlazeUnion(string s) { List <byte> data = new List <byte>(); for (int i = 0; i < s.Length; ++i) { char c = s[i]; if (c == '<' && s.Substring(i, "<Voice:".Length) == "<Voice:") { StringBuilder sb = new StringBuilder(); i += "<Voice:".Length; while (s[i] != '>') { sb.Append(s[i++]); } data.Add(0x02); data.Add(0x00); data.AddRange(HexUtils.HumanReadableHexStringToByteArray(sb.ToString().Trim()).Reverse()); } else { data.AddRange(TextUtils.ShiftJISEncoding.GetBytes(c.ToString())); } } return(data.ToArray()); }
protected void EncodeBase(uint id, int bitness, Code code, string hexBytes, string encodedHexBytes, DecoderOptions options) { var origBytes = HexUtils.ToByteArray(hexBytes); var decoder = CreateDecoder(bitness, origBytes, options); var origRip = decoder.IP; var origInstr = decoder.Decode(); var origConstantOffsets = decoder.GetConstantOffsets(origInstr); Assert.Equal(code, origInstr.Code); Assert.Equal(origBytes.Length, origInstr.Length); Assert.True(origInstr.Length <= IcedConstants.MaxInstructionLength); Assert.Equal((ushort)origRip, origInstr.IP16); Assert.Equal((uint)origRip, origInstr.IP32); Assert.Equal(origRip, origInstr.IP); var afterRip = decoder.IP; Assert.Equal((ushort)afterRip, origInstr.NextIP16); Assert.Equal((uint)afterRip, origInstr.NextIP32); Assert.Equal(afterRip, origInstr.NextIP); var writer = new CodeWriterImpl(); var encoder = Encoder.Create(decoder.Bitness, writer); Assert.Equal(bitness, encoder.Bitness); var origInstrCopy = origInstr; bool result = encoder.TryEncode(origInstr, origRip, out uint encodedInstrLen, out string errorMessage); Assert.True(errorMessage is null, "Unexpected error message: " + errorMessage); Assert.True(result, "Error, result from Encoder.TryEncode must be true"); var encodedConstantOffsets = encoder.GetConstantOffsets(); FixConstantOffsets(ref encodedConstantOffsets, origInstr.Length, (int)encodedInstrLen); Assert.True(Equals(ref origConstantOffsets, ref encodedConstantOffsets)); var encodedBytes = writer.ToArray(); Assert.Equal(encodedBytes.Length, (int)encodedInstrLen); Assert.True(Instruction.EqualsAllBits(origInstr, origInstrCopy)); var expectedBytes = HexUtils.ToByteArray(encodedHexBytes); if (!ArrayEquals(expectedBytes, encodedBytes)) { #pragma warning disable xUnit2006 // Do not use invalid string equality check // Show the full string without ellipses by using Equal<string>() instead of Equal() Assert.Equal <string>(ToString(expectedBytes), ToString(encodedBytes)); throw new InvalidOperationException(); #pragma warning restore xUnit2006 // Do not use invalid string equality check } var newInstr = CreateDecoder(bitness, encodedBytes, options).Decode(); Assert.Equal(code, newInstr.Code); Assert.Equal(encodedBytes.Length, newInstr.Length); newInstr.Length = origInstr.Length; newInstr.NextIP = origInstr.NextIP; if (origBytes.Length != expectedBytes.Length && (origInstr.MemoryBase == Register.EIP || origInstr.MemoryBase == Register.RIP)) { newInstr.MemoryDisplacement += (uint)(expectedBytes.Length - origBytes.Length); } Assert.True(Instruction.EqualsAllBits(origInstr, newInstr)); }
protected void EncodeInvalidBase(int codeSize, Code code, string hexBytes, DecoderOptions options, int invalidCodeSize) { var origBytes = HexUtils.ToByteArray(hexBytes); var decoder = CreateDecoder(codeSize, origBytes, options); var origRip = decoder.IP; var origInstr = decoder.Decode(); Assert.Equal(code, origInstr.Code); Assert.Equal(origBytes.Length, origInstr.ByteLength); Assert.True(origInstr.ByteLength <= Iced.Intel.DecoderConstants.MaxInstructionLength); Assert.Equal((ushort)origRip, origInstr.IP16); Assert.Equal((uint)origRip, origInstr.IP32); Assert.Equal(origRip, origInstr.IP); var afterRip = decoder.IP; Assert.Equal((ushort)afterRip, origInstr.NextIP16); Assert.Equal((uint)afterRip, origInstr.NextIP32); Assert.Equal(afterRip, origInstr.NextIP); var writer = new CodeWriterImpl(); var encoder = CreateEncoder(invalidCodeSize, writer); var origInstrCopy = origInstr; bool result = encoder.TryEncode(origInstr, origRip, out uint encodedInstrLen, out string errorMessage); Assert.Equal(invalidCodeSize == 64 ? Encoder.ERROR_ONLY_1632_BIT_MODE : Encoder.ERROR_ONLY_64_BIT_MODE, errorMessage); Assert.False(result); Assert.True(Instruction.TEST_BitByBitEquals(origInstr, origInstrCopy)); }
override protected void ProcessBuffer(byte[] buffer) { if (CompareFirstN(buffer, End, End.Length)) { _status.FirstLoadedPointNumber = 0; _status.LastLoadedPointNumber = -1; _status.IsFinished = true; return; } var from = HexUtils.ToInt16(buffer, 3 + 22); var to = HexUtils.ToInt16(buffer, 3 + 22 + 2); if (_status.LastLoadedPointNumber + 1 != from) { throw new GH615MCommunicationError(String.Format("Loading error! Expected points from {0}, but get from {1} to {2}!", _status.LastLoadedPointNumber + 1, from, to)); } int offset = 3 + 22 + 4; DateTime timeOffset = _status.TrackInfo.Date; if (_status.TrackPoints.Count > 0) { timeOffset = _status.TrackPoints[_status.TrackPoints.Count - 1].Time; } for (int i = 0; i <= to - from; i++) { GH615MTrackPoint point = GH615MTrackPoint.FromByteArray(buffer, offset, timeOffset); _status.TrackPoints.Add(point); timeOffset = point.Time; offset += 15; } _status.FirstLoadedPointNumber = from; _status.LastLoadedPointNumber = to; }