Original subtitles

1

- [Instructor] Let's check out the second

2

dissembler we've loaded.

3

We'll select GoAsm 64

4

in the configuration.

5

We'll select a classic console application

6

and we'll call the project goatest.

7

Okay.

8

Easy code opens up the project

9

with skeleton code,

10

but we'll remove this and we'll do all the coding ourselves.

11

The first thing we need to do

12

is check the project properties in the tools tab.

13

We can see where I've set the paths

14

for the GoAsm, assembler, linker,

15

and resource compiler tools.

16

We'll also go into tools, settings,

17

and we'll set the default configuration for new projects

18

to GoAsm 64 and on the tools tab,

19

we'll check the debugger path.

20

And set it to X64debug.exe.

21

We'll apply that and close.

22

Let's now put in another simple hello world program

23

this time using GoAsm.

24

Again we won't worry about the coding at this stage.

25

All we want to do is check

26

we have a good installation of GoAsm.

27

We'll start with the data section

28

and define a field for the number of bytes written

29

to be returned as a 64 bit value till you count dq 0.

30

We'll define a hello world message string.

31

Hello db hello 64 world from GoAsm.

32

Now for the code section .code.

33

And the default entry point

34

is to start label again start.

35

We can use the assemblers macro capability

36

to define arguments.

37

In this case, we'll set the value to minus 11,

38

to invoke a request for standard windows,

39

API console output handle arg minus 11,

40

and we'll invoke get standard handle invoke,

41

get standard handle.

42

Next, we'll set up a call

43

to display the message.

44

We'll be invoking the windows right file function.

45

And again, using the arg and invoke macros

46

to set up the parameters.

47

These are coded in the reverse order

48

to the Wynn API documentation,

49

starting with a zero

50

to specify no overlap.

51

The address of the return number of bytes written

52

in the number of bytes

53

we want to write,

54

arg 0,addr wcount,27.

55

Then we provide as arguments

56

the address of our string address hello,

57

and the 64 bit register rax

58

in which we'll pass the handle that we received

59

from the previous invoke core.

60

We can now invoke the right to the console

61

invoke right file.

62

Finally, we'll use an exclusive or trig

63

to clear the rax register,

64

which holds the exit code for the program.

65

Xor rax,rax and ret.

66

Okay, let's go to build build goatest.exe.

67

In the console at the bottom,

68

we can see we've got no errors.

69

We should also check our debugger.

70

Let's go to build debug,

71

goatest.exe and easy code passes us through

72

to the X64debug program,

73

which also provides command shell.

74

I'll minimize the command shell,

75

and maximize the debugger.

76

Okay.

77

To start debugging.

78

We press the icon with the person showing,

79

which runs the code through

80

to our user code.

81

We can see where it's address 401000.

82

And we can see some preliminary

83

instructions before we do a move a

84

to address 401008,

85

where we can see a lot of Fs

86

and finishing with a five that's minus 11 in hexadecimal.

87

Following that we can see a call

88

to get standard handle.

89

We can see here the value

90

of using a simple arg and invoke,

91

which saved us writing six instructions.

92

Let's step through this by pressing F8,

93

as we get to instruction 401012.

94

We can see this RCX has now changed to negative 11.

95

We don't need to spend a lot

96

of time looking at the code at this stage,

97

but if we step down to 401047,

98

and then step over that we can check the console

99

and we can see that our message has appeared.

100

Okay, back in the debugger,

101

we can run to the end of the program

102

and close the debugger.

103

Right, we've now got the easy code ID set up

104

with the X64 debugger installed and running.

105

Or we can choose to use either the masm

106

or the GoAsm assemblers.

107

We're all set for development.

108

And for this course,

109

we'll be focusing on the GoAsm 64 assembler.