public void Test_RET()
{
ushort sp = 0x4242;
byte lsbData = 0x11;
byte msbData = 0x22;
var expectedState = new CpuState();
expectedState.StackPointer = (ushort)(sp + 2);
expectedState.ProgramCounter = (ushort)((msbData << 8) | lsbData);
var actualState = new CpuState();
actualState.StackPointer = sp;
var memoryMock = new Mock <IRandomAccessMemory>();
memoryMock.Setup(m => m.ReadByte(sp)).Returns(lsbData);
memoryMock.Setup(m => m.ReadByte((ushort)(sp + 1))).Returns(msbData);
var instruction = new RET();
instruction.Initialize();
//act
while (!instruction.IsFetchNecessary())
{
instruction.ExecuteCycle(actualState, memoryMock.Object);
}
TestHelper.AssertCpuState(expectedState, actualState);
memoryMock.Verify(m => m.WriteByte(It.IsAny <ushort>(), It.IsAny <byte>()), Times.Never);
}
public ActionResult <RET> Post([FromBody] Models.User value)
{
RET ret = new RET();
try
{
if (value.Id == 0)
{
_context.Users.Add(new Models.User {
Age = value.Age, Address = value.Address, Name = value.Name
});
}
else
{
Models.User user = _context.Users.Find(value.Id);
user.Address = value.Address; user.Age = value.Age; user.Name = value.Name;
_context.Users.Update(user);
}
_context.SaveChanges();
ret.MESSAGE = "OK";
}
catch (System.Exception)
{
ret.MESSAGE = "ERROR...";
}
return(Ok(ret));
}
public void RETHttpPost_ReturnsAViewResult_ViewResultIsNotNull_ObjectIsNotNull()
{
// Arrange
HomeController controller = new HomeController();
RET ret = new RET();
// Act
ViewResult result = controller.RET(ret) as ViewResult;
// Assert
Assert.IsNotNull(result);
}
public ActionResult <RET> Delete(int id)
{
RET ret = new RET();
try
{
Models.User usr = _context.Users.Find(id);
_context.Users.Remove(usr);
_context.SaveChanges();
ret.MESSAGE = "OK";
}
catch (System.Exception)
{
ret.MESSAGE = "ERROR...";
}
return(Ok(ret));
}
internal static bool TryParse(string ASMLine, ASMLine Current, out ASMLine Out)
{
Out = null;
ASMLine = ASMLine.ToLower().Trim();
string[] split = null;
if (ASMLine.Length < 1)
{
return(false); //empty line
}
if (ASMLine[0] == ';')
{
return(false); //comment line, end of section
}
//section headers
if ((split = ASMLine.Split(':')).Length > 1 && Regex.IsMatch(split[0], "^[a-z_0-9]+$"))
{
return((Out = new SectionHeader(split[0])) != null);
}
split = SPR.Split(ASMLine);
switch (split[0])
{
case "nop":
return((Out = new NOP(Current)) != null);
case "movzx":
return((Out = new MOVZX(Current, split)) != null);
case "cmp":
return((Out = new CMP(Current, split)) != null);
case "jnb":
case "jbe":
case "jmp":
return((Out = new JUMP(Current, split)) != null);
case "retn":
return((Out = new RET(Current)) != null);
default:
throw new NotImplementedException($"Unable to parse instruction {split[0]}");
}
}
public List <Row_C_SN_RULE_DETAIL> GetDataByRuleID(string RuleID, OleExec DB)
{
List <Row_C_SN_RULE_DETAIL> RET = null;
string strSql = $@"select * from C_SN_RULE_DETAIL c where c.c_sn_rule_id = '{RuleID}' order by seq ";
DataSet res = DB.RunSelect(strSql);
for (int i = 0; i < res.Tables[0].Rows.Count; i++)
{
if (i == 0)
{
RET = new List <Row_C_SN_RULE_DETAIL>();
}
Row_C_SN_RULE_DETAIL R = (Row_C_SN_RULE_DETAIL)NewRow();
R.loadData(res.Tables[0].Rows[i]);
RET.Add(R);
}
return(RET);
}
public void RET_WhenValuesExceedBound_ShouldNotMeetGoal()
{
// Arrange
int age = 23; double salary = 80000; double saved = 18.2; double goal = 1500000;
double result = 100; bool willMeetGoal = false;
RET ret = new RET();
ret.age = age; ret.salary = salary; ret.saved = saved; ret.goal = goal;
Tuple <double, bool> expected = Tuple.Create(result, willMeetGoal);
// Act
Tuple <double, bool> actual = ret.RETTest();
// Assert
Assert.AreEqual(expected.Item1, actual.Item1, 0.125, "Value of RET does not match expected.");
Assert.AreEqual(expected.Item2, actual.Item2, "", "Value of Goal does not match expected.");
}
public static void AssociateOpcodes()
{
instructions[0] = new NOP();
instructions[1] = new PRNT();
instructions[16] = new PUSH();
instructions[17] = new POP();
instructions[18] = new SAVE();
instructions[19] = new CPY();
instructions[20] = new RNDM();
instructions[21] = new EMPTY();
instructions[128] = new ADD();
instructions[129] = new SUB();
instructions[130] = new MUL();
instructions[131] = new DIV();
instructions[132] = new SUB2();
instructions[133] = new DIV2();
instructions[134] = new NEG();
instructions[135] = new ABS();
instructions[144] = new INC();
instructions[145] = new DEC();
instructions[64] = new JMP();
instructions[65] = new JGZ();
instructions[66] = new JLZ();
instructions[67] = new JEZ();
instructions[68] = new JNZ();
instructions[69] = new CALL();
instructions[70] = new RET();
instructions[71] = new LDLOC();
instructions[72] = new STLOC();
instructions[73] = new LDARG();
instructions[74] = new STARG();
instructions[0b10100100] = new CMP();
public IActionResult RET(RET ret)
{
ViewBag.Title = "Retirement Calculator";
try
{
if (ret == null)
{
throw new ArgumentNullException();
}
double resultAge = ret.CalculateRET();
string resultGoal = ret.DetermineGoalMet();
string result = ("The age you could retire is " + (resultAge.ToString()) + ", " + resultGoal);
ViewBag.Message = result;
return(View());
}
catch (ArgumentNullException)
{
return(View());
}
}
public static Instruction[] PeToInstructions(string FilePath)
{
UnmanagedBuffer buffer = new UnmanagedBuffer(File.ReadAllBytes(FilePath));
List <Instruction> instructs = new List <Instruction>();
Disasm disasm = new Disasm();
disasm.EIP = new IntPtr(buffer.Ptr.ToInt64() + 0x400);
List <int> Addresses = new List <int>();
while (true)
{
int result = Asm.Net.src.BeaEngine.BeaEngine.Disasm(disasm);
Addresses.Add(disasm.EIP.ToInt32());
if (result == (int)BeaConstants.SpecialInfo.UNKNOWN_OPCODE)
{
break;
}
//Console.WriteLine("0x" + disasm.EIP.ToString("X") + " " + disasm.CompleteInstr);
//convert the data to instructions so we are able to execute it in Asm.Net
//We also need to change the pointers for push, call, inc, dec etc... so Asm.Net is able to understand it
switch (disasm.Instruction.Opcode)
{
case (int)OpcodeList.CALL:
{
string tmp = disasm.Argument1.ArgMnemonic.Substring(0, disasm.Argument1.ArgMnemonic.Length - 1).Replace("FFFFFFFF", "");
int Jmpvalue = Convert.ToInt32(tmp, 16);
CALL call = new CALL(Jmpvalue);
call.NativeVirtualAddress.Address = disasm.EIP.ToInt32();
instructs.Add(call);
break;
}
case (int)OpcodeList.INC_EAX:
{
INC_EAX IncEax = new INC_EAX();
IncEax.NativeVirtualAddress.Address = disasm.EIP.ToInt32();
instructs.Add(IncEax);
break;
}
case (int)OpcodeList.INC_EDX:
{
break;
}
case (int)OpcodeList.JE:
{
break;
}
case (int)OpcodeList.JMP:
{
string tmp = disasm.Argument1.ArgMnemonic.Substring(0, disasm.Argument1.ArgMnemonic.Length - 1);
int Jmpvalue = Convert.ToInt32(tmp.Replace("FFFFFFFF", ""), 16);
JMP jmp = new JMP(Jmpvalue);
jmp.NativeVirtualAddress.Address = disasm.EIP.ToInt32();
//instructs.Add(jmp);
break;
}
case (int)OpcodeList.JNZ:
{
string tmp = disasm.Argument1.ArgMnemonic.Substring(0, disasm.Argument1.ArgMnemonic.Length - 1);
int Jmpvalue = Convert.ToInt32(tmp.Replace("FFFFFFFF", ""), 16);
JNZ jnz = new JNZ(Jmpvalue);
jnz.NativeVirtualAddress.Address = disasm.EIP.ToInt32();
//instructs.Add(jnz);
break;
}
case (int)OpcodeList.MOV_EAX:
{
string tmp = disasm.Argument2.ArgMnemonic.Substring(0, disasm.Argument2.ArgMnemonic.Length - 1);
int MovValue = Convert.ToInt32(tmp, 16);
MOV_EAX MovEAX = new MOV_EAX(new VirtualAddress(0, MovValue));
MovEAX.NativeVirtualAddress.Address = disasm.EIP.ToInt32();
instructs.Add(MovEAX);
break;
}
case (int)OpcodeList.NOP:
{
NOP nop = new NOP();
nop.NativeVirtualAddress.Address = disasm.EIP.ToInt32();
instructs.Add(nop);
break;
}
case (int)OpcodeList.PUSH_EAX:
{
break;
}
case (int)OpcodeList.RET:
{
RET ret = new RET();
ret.NativeVirtualAddress.Address = disasm.EIP.ToInt32();
instructs.Add(ret);
break;
}
case (int)OpcodeList.ADD:
{
//need to reverse check the opcodes...
Instruction ADD = null;
switch (disasm.Argument1.ArgMnemonic)
{
case "eax":
{
switch (disasm.Argument2.ArgMnemonic)
{
case "al":
{
ADD = new ADD_BYTE_PTR_EAX_AL();
break;
}
}
break;
}
}
if (ADD != null)
{
ADD.NativeVirtualAddress.Address = disasm.EIP.ToInt32();
instructs.Add(ADD);
}
break;
}
case (int)OpcodeList.XOR_REGISTER:
{
Instruction xor = null;
switch (disasm.Argument1.ArgMnemonic)
{
case "eax":
{
switch (disasm.Argument2.ArgMnemonic)
{
case "eax": { xor = new XOR_EAX_EAX(); break; }
case "ecx": { xor = new XOR_EAX_ECX(); break; }
case "edx": { xor = new XOR_EAX_EDX(); break; }
case "ebx": { xor = new XOR_EAX_EBX(); break; }
case "esp": { xor = new XOR_EAX_ESP(); break; }
case "ebp": { xor = new XOR_EAX_EBP(); break; }
case "esi": { xor = new XOR_EAX_ESI(); break; }
case "edi": { xor = new XOR_EAX_EDI(); break; }
}
break;
}
case "ecx":
{
switch (disasm.Argument2.ArgMnemonic)
{
case "eax": { xor = new XOR_ECX_EAX(); break; }
case "ecx": { xor = new XOR_ECX_ECX(); break; }
case "edx": { xor = new XOR_ECX_EDX(); break; }
case "ebx": { xor = new XOR_ECX_EBX(); break; }
case "esp": { xor = new XOR_ECX_ESP(); break; }
case "ebp": { xor = new XOR_ECX_EBP(); break; }
case "esi": { xor = new XOR_ECX_ESI(); break; }
case "edi": { xor = new XOR_ECX_EDI(); break; }
}
break;
}
case "edx":
{
switch (disasm.Argument2.ArgMnemonic)
{
case "eax": { xor = new XOR_EDX_EAX(); break; }
case "ecx": { xor = new XOR_EDX_ECX(); break; }
case "edx": { xor = new XOR_EDX_EDX(); break; }
case "ebx": { xor = new XOR_EDX_EBX(); break; }
case "esp": { xor = new XOR_EDX_ESP(); break; }
case "ebp": { xor = new XOR_EDX_EBP(); break; }
case "esi": { xor = new XOR_EDX_ESI(); break; }
case "edi": { xor = new XOR_EDX_EDI(); break; }
}
break;
}
case "ebx":
{
switch (disasm.Argument2.ArgMnemonic)
{
case "eax": { xor = new XOR_EBX_EAX(); break; }
case "ecx": { xor = new XOR_EBX_ECX(); break; }
case "edx": { xor = new XOR_EBX_EDX(); break; }
case "ebx": { xor = new XOR_EBX_EBX(); break; }
case "esp": { xor = new XOR_EBX_ESP(); break; }
case "ebp": { xor = new XOR_EBX_EBP(); break; }
case "esi": { xor = new XOR_EBX_ESI(); break; }
case "edi": { xor = new XOR_EBX_EDI(); break; }
}
break;
}
case "esp":
{
switch (disasm.Argument2.ArgMnemonic)
{
case "eax": { xor = new XOR_ESP_EAX(); break; }
case "ecx": { xor = new XOR_ESP_ECX(); break; }
case "edx": { xor = new XOR_ESP_EDX(); break; }
case "ebx": { xor = new XOR_ESP_EBX(); break; }
case "esp": { xor = new XOR_ESP_ESP(); break; }
case "ebp": { xor = new XOR_ESP_EBP(); break; }
case "esi": { xor = new XOR_ESP_ESI(); break; }
case "edi": { xor = new XOR_ESP_EDI(); break; }
}
break;
}
case "ebp":
{
switch (disasm.Argument2.ArgMnemonic)
{
case "eax": { xor = new XOR_EBP_EAX(); break; }
case "ecx": { xor = new XOR_EBP_ECX(); break; }
case "edx": { xor = new XOR_EBP_EDX(); break; }
case "ebx": { xor = new XOR_EBP_EBX(); break; }
case "esp": { xor = new XOR_EBP_ESP(); break; }
case "ebp": { xor = new XOR_EBP_EBP(); break; }
case "esi": { xor = new XOR_EBP_ESI(); break; }
case "edi": { xor = new XOR_EBP_EDI(); break; }
}
break;
}
case "esi":
{
switch (disasm.Argument2.ArgMnemonic)
{
case "eax": { xor = new XOR_ESI_EAX(); break; }
case "ecx": { xor = new XOR_ESI_ECX(); break; }
case "edx": { xor = new XOR_ESI_EDX(); break; }
case "ebx": { xor = new XOR_ESI_EBX(); break; }
case "esp": { xor = new XOR_ESI_ESP(); break; }
case "ebp": { xor = new XOR_ESI_EBP(); break; }
case "esi": { xor = new XOR_ESI_ESI(); break; }
case "edi": { xor = new XOR_ESI_EDI(); break; }
}
break;
}
case "edi":
{
switch (disasm.Argument2.ArgMnemonic)
{
case "eax": { xor = new XOR_EDI_EAX(); break; }
case "ecx": { xor = new XOR_EDI_ECX(); break; }
case "edx": { xor = new XOR_EDI_EDX(); break; }
case "ebx": { xor = new XOR_EDI_EBX(); break; }
case "esp": { xor = new XOR_EDI_ESP(); break; }
case "ebp": { xor = new XOR_EDI_EBP(); break; }
case "esi": { xor = new XOR_EDI_ESI(); break; }
case "edi": { xor = new XOR_EDI_EDI(); break; }
}
break;
}
}
if (xor != null) //this check is just for temp, not all the XOR instructions are added
{
xor.NativeVirtualAddress.Address = disasm.EIP.ToInt32();
instructs.Add(xor);
}
break;
}
}
disasm.EIP = new IntPtr(disasm.EIP.ToInt64() + result);
}
//set all the pointers correct
int offset = Options.MemoryBaseAddress;
foreach (Instruction instruction in instructs)
{
switch (instruction.ToByteArray()[0])
{
case (int)OpcodeList.CALL:
{
break;
}
case (int)OpcodeList.INC_EAX:
{
break;
}
case (int)OpcodeList.INC_EDX:
{
break;
}
case (int)OpcodeList.JE:
{
break;
}
case (int)OpcodeList.JMP:
{
//lets set our new jmp pointer, We also should load the modules which are required to run this program
//We need to load the Import Table and get all the .dll's from it and getting all the instructions from it
bool NewSet = false;
foreach (Instruction instruct in instructs)
{
if (Addresses.Contains(((IJump)instruction).JumpAddress))
{
//Set the ASM.net pointer
int index = Addresses.IndexOf(((IJump)instruction).JumpAddress) - 1;
}
//if (((IJump)instruction).JumpAddress == instruct.NativeVirtualAddress.Address)
//{
//}
}
//if (!NewSet)
// throw new Exception("Unable to find the JMP Pointer, Invalid memory address ?");
break;
}
case (int)OpcodeList.MOV_EAX:
{
break;
}
case (int)OpcodeList.NOP:
{
break;
}
case (int)OpcodeList.PUSH_EAX:
{
break;
}
case (int)OpcodeList.RET:
{
break;
}
}
instruction.VirtualAddress.Address = offset;
offset += instruction.VirtualAddress.Size;
}
return(instructs.ToArray());
}
