Join me as I break down a simple yet powerful x86-64 YASM assembly program to copy files using system calls! Learn how to open input files, create output files, and use a looping buffer for efficient data transfer. I’ll demo the code, explain file handles, permissions, and error handling, and even verify the copy with MD5 checksums. Perfect for intermediate assembly programmers or anyone curious about low-level file operations. Check out my other videos for more assembly tips, and don’t forget to subscribe!

Introduction to File Copy Program 00:00:00
System Calls in YASM Assembly 00:00:06
Opening Input File 00:00:17
Creating Output File 00:00:22
Using Looping Buffer 00:00:28
Assembly Program Prerequisites 00:00:37
Overview of Source File 00:00:53
Data Section and Strings 00:01:06
Copy Buffer Length 00:01:21
File Permissions Explanation 00:02:05
System Call Codes 00:02:57
File Descriptors and Exit Codes 00:03:24
Text Section and Entry Point 00:03:45
Welcome Message Function 00:04:01
Print Null Terminated String 00:04:16
Running Initial Program 00:06:26
MD5 Checksum Explanation 00:07:00
File Tests Function Introduction 00:07:28
Open File Read Function 00:09:52
Checking File Handle 00:14:00
File Handle Concept 00:14:25
Error Handling Importance 00:15:24
Testing File Open 00:23:00
Create File Function 00:31:16
Testing File Creation 00:32:36
Copy File Function 00:36:14
Stack Buffer Creation 00:38:16
While Loop for Copying 00:40:14
Read System Call 00:40:47
Write System Call 00:45:03
Checking Read/Write Operations 00:46:51
Final Program Run 00:49:00
Verifying File Copy with MD5 00:49:22
Testing with Larger Input 00:51:20
Optimizing Buffer Size 00:53:41
Conclusion and Call to Subscribe 00:54:41

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social

Please help support us!

• Subscribing + Sharing on Social Media
• Leaving a comment or suggestion
• Subscribing to our Blog
• Watching the main “pinned” video of this channel for offers and extras

Hey everybody in this video i’m going to show and explain a simple program that copies a file

using system calls in an x8664 yasm assembly program

we’re going to use the system calls to open an input file and read characters from it we’re

going to use another system call to create a destination file and write characters to it

we’re going to use a looping buffer,

which should be kind of fun in the middle.

And I’m just going to do my best to explain as much as I can.

I should say though that before you can watch this video,

you probably already need to know how to program an assembly,

at least in a basic level, Yasm assembly.

And so if you don’t know how to do that yet,

this video is probably going to be confusing for you.

You probably need to look at my other videos dealing with Yasm assembly and

system calls and so forth.

So I’m just going to show you real fast what’s actually going on in this source

actually going on in this source file so far.

So this is my assembly program.

It’s not finished.

I’m going to write it on screen for you.

For the most part, you can see I’ve got a data section here and then I just have a

bunch of null terminated strings.

So I’ve got a string saying, hey, the module started.

We’re about to open the file.

We’re about to create the file.

We failed to do something.

We’re done copying.

You know, we terminated the program, you know, whatever.

Right. So I just have some strings.

No big deal.

Down here, I have something called the copy buffer length, which is which is just

length with just which is just the size of the buffer that I’m going to use

between the input file and the output file so a two byte buffer is really

inefficient it’s too small but I made it two bytes just to show to you that are

looping you know a read area is going to actually work because if I make a buffer

that’s too big if it’s bigger than the file then we won’t actually know if the

if the buffer loop works or not so I’m just gonna put two here could change

that later if we wanted to we’re gonna be reading from a file called input and

called input and writing to a file called output so that’s no big deal in order to open a file with

a system call for read mode we’re just going to use a zero as the flags that just means read mode

and then for the creation of the file we’re going to use some standard permissions this is not a

permissions video I’m going to probably release a permissions video at some later point in time

not too important right now but basically this 640 is the heart of what permissions we’re actually

what permissions we’re actually looking at.

Q is quad word.

And six just means that the owner can read

and write to the file.

Four means that anyone who is in the same group

as the file has been assigned to,

which is usually the owner,

can just read it but not write to it.

And then everybody else,

people who are not the owner

and who are not in the right group,

they have no access to it.

Just a simple security feature of Linux

for file permissions.

You can go a lot further than this in the terminal,

in the terminal, but for this assembly program,

we’re just gonna use basics.

We’re not gonna use ACLs.

I don’t even know how to do that in assembly.

System call codes.

So again, if you don’t understand system calls,

you gotta watch my other videos first,

but we have a code of zero to read from a file,

one to write to a file, two to open a file,

three to close and open file.

Probably should have put that one before create,

but I don’t really care.

85 is the code to create a file for writing,

to create a file for writing and then 60 is the code to exit from the program.

So then we have file descriptors.

Descriptor number one is a standard output.

Descriptor number two is standard error.

And it’s always one and two, no matter what program you’re dealing with.

Unless you have some kind of really crazy non-standard thing going on.

And then for the exit codes, we’re just going to say exit zero for success and exit one

for failure.

Now to the actual tech section where our instructions are in the assembly program.

in the assembly program.

So you can see section text here.

We’ve got a global entry point called underscore start.

So this is not a GCC program that requires a main entry point.

This is a pure assembly program that requires

an underscore start entry point.

Again, see my other videos for more assembly explanation.

I’m gonna call on a method,

well, not a method of regular function called welcome.

Just to print a little welcome message,

you can see right here, that’s all that’s doing.

It’s just loading, you know, a string,

sending it to standard output, and calling on a helper function that I made called print null

terminated string. When it’s done with that, it just uses the call code to exit the program.

No big deal. Nothing too advanced so far. I have the tests function commented out because I want

to write that in front of you. And if you look at what I have inside of print null terminated string,

this is not the point of the video, so I’m just going to skim it. It’s not super important.

called print null terminated string that takes in a pointer to a character array

and a file handle for where you want to print it and what it’ll do is it’ll come

in grab the incoming arguments it’s only got two arguments so it uses r12 and r13

to store those arguments and then r14 is the result of calling another helper

called string length you can imagine my string length function just kind of

scans the string until it finds a null terminator aka the number zero not the

zero but actually a zero in order to figure out how long the string is and then it can use a

regular system call to print the string to the right file descriptor so we’re going to be doing

most mostly this kind of this exact same thing when we copy the file so I’m just definitely not

going to explain it if you don’t know pushes and pops and epilogues and prologues see my other

videos crlf is just going to print a carriage return new line so it or sorry carriage return

sorry, carriage return line feed.

So that’s just like making the cursor go to the next line.

Not a big deal.

We just print a string basically.

And then I have a custom die function

that allows us to die with a failure code of one.

Oh, I forgot to mark that.

Let’s see, 206 exit fail.

I’m just gonna put that down here.

Yeah, instead of hard coding values,

it’s a lot better to use variables if you can or defines.

So all that’s gonna do is just kind of print

an error message and then exit

then exit with the you know the appropriate

Exit code which is just going to be one because this is a simple program

So CRLF print an alternated string dying string length a welcome message all this fun pretty stuff

That doesn’t really do anything except make the program more fun to look at so I’m going to run it here and make sure that actually works

Okay

Nice, okay, so if I run it you can see that the the make file system again

file system again this is not a make file video so I’m not going to show you

my make file see my other videos if you want to learn more about make files but

you can see that the assembly program says that it started and then it just

exited then the make file continues to run these extra commands that I have

set up so this is not part of the assembly program this is just taking a

checksum an MD5 checksum of the input file and then an MD5 checksum of the

what empty five checksums are i’ll probably release a video sometime in the future if you’re

interested on all my platforms just talking about why we why you would use a checksum but for now

just imagine this is a fingerprint so if the fingerprints don’t match that means the files

don’t match right now the output file doesn’t even exist so it just is an error and that’s why the

make file thinks there’s an error because the output file didn’t exist so that’s the basics

of kind of getting started with this you know bare bones program now let’s start looking at running

program. Now let’s start looking at running the file tests. So file tests, we got to make a new

method. I’m going to stick it down here. Let’s see. I got a solution up so that I don’t have to

spend too much time typing. I’m going to try my best to balance between copy pasting and just

typing very quickly. But let’s see, where’s the file test? So we got this. I’m going to put the

I’m feeling pretty lazy.

I’m just going to copy paste the whole thing.

Copy paste the whole thing.

So now this method right here is going to get called the file tests.

I keep saying method because I teach C++ a lot too.

File tests.

If we go down further, this function is called file tests.

Here’s the signature.

It doesn’t take any arguments.

It just kind of does stuff.

It doesn’t return anything.

And here are the registers that I’m going to use.

the input file handle, the output file handle, and then the count of bytes read from the input

file at any given time inside of our looping buffer reader section. So the first thing I’ve

got to do is I’ve got to open a file to read. The second thing I’ve got to do is create a file to

write. And then I’m going to copy the input file to the output file. And then I’m going to print

a message saying, hey, everything was successful. And then I’m going to close both files. Notice how

anything i’m just sort of calling other functions do the work for me again if you don’t know the

prologue and epilogue stuff or calling functions and returning you should see my other videos

but i just like to use helper functions assembly is like so unwieldy right it’s it just gets out

of control so quick and so confusing so fast so anytime you can just you know take a chunk out

of your assembly code and move it somewhere to another module or to another function

going to make your life a lot easier and make debugging a lot easier people who try to write

the entire portion of their program in just one gigantic function those are the people who usually

end up spending 10 times longer debugging for no reason at all so i believe in the power of modular

thinking so anyway what are we going to do inside of the open file read function it’s not too bad

to be honest let’s see if i can find it real quick open file read i’m going to copy paste it because

Again, I’m pretty lazy.

I’ll just explain what it is though.

So down here we need a function called open file read.

So I’m just going to do that.

And you can see the signature that I’ve chosen for this is, you know, I like to

write all my functions in C++, uh, kind of lingo or prototypes so that I can have a

better understanding of what the assembly is actually supposed to do.

So you can see the function called open file read.

I want it to take two arguments.

two arguments the first argument should be a pointer to a string that represents the file

name that i want to open and it should be null terminated again if you look back at my uh at

my strings up here they all have little zeros at the end so they are all null terminated anyway uh

so that’s the first argument that’s going to show up as rdi in assembly and then the second argument

is the flags for opening the file so i think probably that was redundant if i if i name this

that was redundant if i if i name this open file read then i think it should be obvious that the

flags are just going to be the read flags only so i probably didn’t even need to provide this

that was bad design on my part you could write a better one on your own where it’s just one argument

and if the name is read then just use the read flags but if the maybe if you want to leave the

flags in there you could just say open file only it’s up to you anyway so it attempts to open a

successful it’ll return the file handle that’s the long return type right here

long file handle if it fails then it will just basically complain and exit

the program you probably want a more sophisticated way of handling errors in

your program I just decided to complain and exit the entire program because this

is you know not supposed to be super complicated I just want to show you how

to copy files and then for me I like to leave comments that just sort of explain

And once my functions get so complicated that I actually run out of registers,

then that tells me I probably need to just make another function,

you know, split the work up in some way.

So far, so good.

I only end up reusing the same registers for multiple purposes occasionally.

I’m not a hardcore assembly programmer.

I’m just, you know, I’m like medium.

So I’m going to use R12 and 13 and 14.

That’s why we have the prolog pushing all those registers to preserve them

pushing all those registers to preserve them because they’re callee saved and then the epilogue

epilogue that just kind of pops them i’ve got a label here for the function remember a function

is just a label and then a return statement as long as you obey and respect the abi like preserving

certain registers then you should be okay first thing i’m going to do is grab the incoming

arguments so i’m going to grab the file name which is a pointer which means it’s just a 64-bit

integer i can stick that into a register and then the flags same thing so i’m going to grab

rdi and rsi the incoming arguments i’m going to stick them into r12 and r13 so the character

pointer in the flags and then i’m going to attempt to open the file with a system call so

system call is right there line 168 if you look up the table for system calls in my favorite book

that i usually recommend or any table that knows the system call codes for x86-64 assembly

call code to open a file is some number i’ve assigned that to sys open if we look up here

open is code 2 so that’s why i you know i don’t want to remember the numbers it’s bad to hard

code number so i just i just put it as a define and then the first argument that it wants in rdi

is the name of the file so i just gave it r12 i guess i probably could have just used rdi

directly in the system call but that tends to make me nervous reusing the argument registers

registers, I like to have them somewhere where they’re not going to be destroyed.

If I like, let’s say I accidentally added some code here on line 163.

If I wanted to reuse RDI and I accidentally added some code there,

then RDI would have been destroyed.

Would have cost me a bunch of time debugging my program.

Although I admit it’s not super efficient to do it that way.

Then we’re going to do the file status

flags as the second argument, and then we just do a system call right away.

register gives you the result of your system call.

Notice how we use RAX to send in the call code.

And then the system call sends us back its return result also in the RAX

register. So I’m just going to save that right away to R14.

You can see up here, it’s just the file handle.

So we can assume maybe at this point that we have a file handle sitting in R14.

You know, what is a file handle when you ask the system to open a file for you?

The operating system under the hood is just going to do a bunch of stuff to

bunch of stuff to actually open a file it’s going to go it’s going to take the string

that you sent it and it’s going to parse it and figure out you know how do i how do i interpret

where that actually is on disk i’m going to look at like the file system in the past that you

provided i’m going to look at the mount points and i’m going to figure out like where exactly on disk

does that file start and then the operating system stores that the operating system stores the file

name it stores where you’re looking at the file currently stores a bunch of stuff that you don’t

a bunch of stuff that you don’t want to have to remember you know it creates data structures under

the hood and all it’ll give you back in return is a file handle for simplicity because then later

you can use that file handle to just sort of say I would like to write some bytes to a file or I

would like to read some bytes from an open file here’s the handle you gave me previously and then

it’ll just work assuming you have a valid handle so the handle is kind of the most important part

failed because it’s a mistake i’ve said this in other videos it’s a mistake that new programmers

make or lazy programmers make uh let’s suppose for the sake of argument uh uh file open sys call

pretend we’re in c plus plus and there is some sort of an api function that we can call either

directly to the system or some person’s library and it’ll open a file for us so maybe like a

just say we call this right so i’m going to do like a little comment if inside of your program you just

call it with the you know some some path and then you assume that what you have is a valid you know

handle if you assume that what you got back is a valid handle or maybe this is not a function

just assume that the call succeeded, your program is probably going to have errors when you least

expect it. And it’s not going to look good. Especially if you release a function like this

to the public, or if you have like a professor who’s like grading your code and they are testing

to see if you’re checking for return codes and stuff like that. That’s not a smart idea, right?

Like you shouldn’t, should not, shouldn’t proceed as if everything went according to plan. What,

just proceeding as if everything went according to plan.

You want to use an if statement, right?

You want to say if the handle has some value that seems to be valid,

like for example, more than zero in the case of opening a file,

I would say probably more than two because all of our programs

always have automatically assigned file handles of zero and one and two

to represent standard input, standard output, and standard error.

But I think usually people just say like,

if it’s greater than zero, then it’s fine.

zero then it’s fine uh you know for me i might put greater than two but more than zero is fine

the point is check to make sure that it actually succeeded

do i have spell check on this thing oh god you’re all going to see my true spelling let me see if i

can get it on real fast plug-ins what how come this oh okay now it’s highlighted

If we’ve succeeded based on some kind of a comparison of the return result,

then we’ll proceed in one way.

Otherwise we’ll respond to the error by, you know, doing something else.

Somehow, like writing a log file, sending an email, complaining to the user,

doing any number of things where you can actually respond to the error.

Maybe you probably want to change your execution path.

Like if the file successfully opened, then go ahead and start writing to it

or reading from it or whatever.

But if the file did not successfully open,

want to do something else in the program and not just start trying to read from the file so anyway

super super good idea and so that’s why i’m going to implement that inside of assembly 2. so instead

of just immediately using the file handle i’m going to check it i’m going to say let’s compare

it to the number zero if we succeeded then let’s go to another label called uh read success i

personally when i’m doing branching logic i like to say open file read is the name of the function

read is the name of the function and I’ll just I’ll just uh uh append some kind of a suffix

to the original function name that way it’s it’s easier to avoid collisions when you have lots of

functions and lots of labels and things like that so I’m basically saying if we succeeded I’m going

to jump to this label which is down here and so uh this video also is not about branching logic

and and how to implement those instructions you can probably infer it by looking at my code but

it by looking at my code but you know see another video in the future for that topic anyway if we

succeeded in opening the file handle then we’re just going to say oh we were successful and then

we’re going to uh um let’s see we’re going to print the name of the file that we just successfully

opened and then we’re going to send the file handle into rax so that this function has a return

So when you open a file to read successfully, the caller will receive the file handle.

You might be wondering yourself, wait a minute, wait a minute, wait a minute.

It just gave us the file handle in RAX.

Remember, we got to respect the ABI.

Anytime we jump anywhere or call another function or call another syscall,

which a lot of these things do,

we will probably lose the value of registers that are not callee preserved.

And that’s definitely RAX.

I mean, just doing any system call like this print null terminated string function does.

print null terminated string function does that’s going to destroy rex so that’s why i saved it away

first in r14 then at the very end of the function right before i return i’m just going to grab r14

and send it into rex again respect the abi do not return data as a return value in r14 or any other

register you have to use the designated registers and in this case an integer that you’re returning

x anyway so that’s the gist of that let me go back up for a second uh so notice how

we’re we’re sort of comparing oh gosh i just i just reconfigured my annotator and i bought a

new drawpad i wonder if this is going to work ah it works there’s a bunch of stuff i added too

so notice how uh we try to open the file and then we sort of compare the file handle to see if we

off to the success area down here oh my green’s not working oh it’s tricky it’s tricky i gotta

hit it in a certain way there we go if it succeeds we go down here to the success label so we

basically at that point um totally ignore all of the fail code right we’re just like branching

around on the other hand if it fails then execution falls through because it’s not going to jump

if uh if if r14 is not greater than or equal to zero so if we fail maybe i should put this in a

red if we fail then it’s going to fall through to the next label and then the next instructions

some people like to say let’s uh let’s jump to the success label and then if not let’s jump to

the fail label that can buy you a little bit more uh i don’t know jump length if you have a giant

program but in this case i’m just going to let it fall through it saves us one jump instruction

and so if it fails then it’s going to say first off let’s print a message that we failed

to standard error if you want a refresher on standard input standard output and standard error

see my other videos and then it’s going to print the name of the file that failed so that’s this

part right here it’s going to say hey we we failed to print or sorry we failed to open this file name

for reading and it’s going to print a new line there with the crlf thing

and then it’s actually going to exit the program at that point it’s going to say all right we

failed and so the whole program just just quits and that’s my die function that i showed you

earlier it’s just going to call the system call code for quitting and it’s going to give a return

code of one to indicate to anyone automating our program including new make that well our program

failed at least it failed okay so we got all that and then we got the success and so now you kind

of know the idea behind opening a file let’s do that real fast just for fun so file tests

um oh i know what to do i’ll just comment out these uh instructions just so that we’re only

doing the file open yeah that’s pretty good and then we won’t close anything just yet

so now let me run this in the terminal real fast make run it says it successfully opened

it says it successfully opened the file input.txt

and then the program exited.

No problem, that error code one,

that’s because the output file doesn’t actually exist.

So don’t worry about that.

And let’s change the name of the input file

just to show you that it can fail and we can detect it.

I’m gonna put a two there

so that the program will try to open an input file

that doesn’t actually exist.

And then I’ll run it again.

Notice how it says fail to open file input2.txt.

And then it says terminating program after failure to open file.

And then this time, notice how the make file never got far enough

so that it tried to print the MD5 sums of the input and output files.

The assembly program just failed.

And so GNU make said, I’m not going to proceed any further.

Kind of useful when your program gives good exit codes, right?

Because then other programs know when to stop

or maybe what to do depending on what’s happening.

So I’m just going to fix this real fast.

down here and maybe the next thing I want to add is closing the files so we’ve got a function to

open a file for reading and then we have a function down here that is not implemented yet

for closing the files so I’m going to do let’s see what is r12 r12 is the input file so I’m

going to close r12 so basically this function it’s going to it’s going to take one argument

handle. So that’s why I’m giving the file handle of the input file as the first argument. And then

I’m just going to call it. So let’s copy paste close file underneath this. So I’m going to do

like some more space. And let me let me go get this from my solution close file.

And it’s going to be a pretty simple one. Really nothing much to it. I’m just going to write my

C++ prototype saying, well, it takes in one argument and it’s a handle. It doesn’t return

argument and it’s a handle it doesn’t return anything it attempts to close a

file and I’m just gonna use R12 to hold the incoming argument your programs at

home should probably be a little bit better than mine you should check to see

if the file successfully closed or not and respond in some kind of a way but

for me I’m just saying I don’t really care I already showed you that we can

check for a return value so I’m allowed to be lazy now and just sort of try to

close it and then just assume it all went according to plan so grabbing the

So grabbing the incoming arguments here.

That’s why I’m using R12.

That’s why I’m doing a push-pop pair.

And then the system call code to close is pretty easy.

You just say, here’s the code to close.

Stick that in RAX.

Let me go up real fast.

Notice how sysclose is the call code number three

on line 43 there.

So I send it the call code three to say, let’s close a file.

It only wants one argument, which is just,

what is the file handle that you want me to close?

what is the file handle that you want me to close remember before the operating system created a

bunch of stuff under the hood and gave you a file handle you can then use the file handle

to close a file read a file write to the file whatever to the file so it’s pretty easy once

i’ve set up the incoming arguments to the system then i actually use the system call instruction

syscall and then i can assume it’s probably closed at that point then a return statement at the end

like any additional thing happening.

It should just be, it said it successfully opened the file

and then it just exited.

Okay, now we’re ready to add a little bit more.

Let’s create a file to write.

So this is going to be the same thing basically

as opening a file to read,

except it’s going to be a different call code

and we’ll give it initial file permissions

rather than a read mode flag.

But then we’ll just get a file handle in return.

get a file handle in return.

And I’ve also stuck this into another function, of course.

So the file name to write line 109.

If you just scroll up real fast here, or if I scroll up real fast,

it’s a line 27 here, just output.txt.

And then the file permissions that we want to use.

I’m going to scroll up here.

That’s the second argument to the system call code.

That’s just the stuff that I talked about a little while ago where it’s like,

we want the user to be able to read and write to the file.

to be able to read and write to the file we want people in the same group to be able to read only

and we want everyone else to not be able to do anything basic linux permissions not a big deal

at the end you should probably maybe note that uh you know this q i think i might have said this

before this q just means quad word and these zeros are always going to be the same so really it’s just

like three numbers representing file permissions i’ll go over that in more detail in some other

So for now, we know that we’re going to open a file name to we’re going to open a file

for writing doesn’t have to exist yet.

We’ll give it some default permissions.

And those are the incoming arguments to the function that we’re going to call now called

create file.

When that file when that function comes back, assuming it didn’t decide to exit the program

because we failed to open the file, we will receive the file handle in our ex per usual.

And so I’m just going to stash that away real fast into our 13.

Remember R12 has the handle to the input file.

R13 has the handle to the output file.

And then, you know, for me personally,

I put that in comments to help myself remember

what I’m even doing,

because things can get confusing really, really fast.

And while we’re at it,

before we even write the create file function,

I might as well just uncomment these things at the bottom,

just to say, let’s close both files properly.

You always want to do that.

let’s copy paste the create file function let’s see I didn’t do that already right yeah okay

so let’s do that maybe like right here I’m going to go grab it from my solution real fast create

file okay about as complicated as opening a file just because I put in some some checking logic to

see if it successfully opened the file which is a good idea so here’s my function create file

arguments. Oh shoot, file creation hand. Let’s see, am I using R13? Yeah, oh, I mislabeled that.

Instead of saying flags, it should be permissions. So let me just do perms here. Long perms,

file creation perms, perm. I wish I could get a perm, if you know what I mean. Anyway, so,

you know, we just have like the file name that comes in and the permissions that come in,

And it’s going to return a handle just like we did with the read file for opening function.

But this time we’re going to do something slightly different.

So the system call is going to be the code for creating a file.

SYS create, which is not real unless you define it.

So if we just look up, I define that as.

Where is it?

Create 85.

So like right here, code 85 for system create.

Again, not a smart idea to hard code numbers.

Defines are way better.

numbers defines are way better. So then the first argument that it wants is the name of the file.

That’s the incoming argument that I took into R12. It has to be a null terminated string. It’s going

to be output.txt. Then the second argument is the file’s permissions. So that’s R13 that I took here

from the second argument, long perms. Once I’ve set up those things, I can do the system call

right away. The system, again, will try to open the file. It’ll try to create the file,

set up some data structures under the hood. If it succeeds, it’ll give me a valid file handle

in RAX, the return register. If not, then things have failed and I need to respond to that. So

I’m just going to stash the file handle in R14 right away. That’s why I’m also preserving R14

in the push pop pair that I have, R14 up at the top and the bottom.

So now we got to check whether or not we successfully created the file. Again,

logic is just opening up off a reading I’m going to compare our 14 to zero if

it’s greater than zero I’m going to assume it’s a valid file handle so jump

if it’s greater than or equal to to that label create file success I’m still

using my appending can naming convention so the name of the function is create

file so that means the success area is create file and then append underscore

success and so then I’m just gonna you know print a cute message saying hey we

successfully created the file. Yay.

Same thing that we looked at before basically.

And then I’m going to return the file handle in RAX.

If we fail, same thing that we did before when we were opening a read file,

I’m just going to complain basically to the user and then call on my little

die function to properly exit the assembly program with a

exit code of one, you know,

and I could enhance that to exit with different codes. Like maybe exit code.

Maybe exit code one means the read file didn’t work and exit code two means the

write file didn’t work and exit code three means we failed for some reason

while we were copying the data, you know, whatever you want.

I’m keeping it kind of simple.

So we got all that.

Again, this is not different than reading just, you know, the call codes pretty

much and, you know, the arguments, but the idea is the same.

So now we’re ready to uncomment.

I think we actually already did that.

We’re ready to let the program try to create the file.

to create the file and the only thing we need to add after that is the copying portion and the

successful message so let’s see if this works do clear and make run so you can see that the program

starts running here and then it says okay the module started and then it says we successfully

opened the read file and then we successfully created the output file notice how the make file

doesn’t fail when it tries to call the md5 checksum of the output file because now it actually exists

because now it actually exists if we list the program uh list the directory here you’ll see

that the out file has actually been created it just has a length of zero because there’s nothing

inside of it notice also that the permissions match what we intended the initial user can read

and write or the owning user can read and write the group can only read and everybody else can do

nothing to heck with you we could change that real fast just to show you i can get this r to

show you i can get this r to turn into an rw just by modifying permissions up here

you know giving permissions to a group uh just is a nice way of allowing multiple users

to have a shared file location you know add them all to the same group and then set that group

onto the file and then set the group permissions to allow people to do whatever you want them to

do read or read and write or whatever so let’s see where the perms i’m going to change this

So now the group people should be able to read and write.

I can’t remember if this will work because the file already exists.

Let me give it a try.

Okay.

I ran it one more time and it looks like it did not create the file because it already

existed.

So let me just remove output.txt.

There should be another system call code you could use to just check to see if a file

exists or if you wanted to be kind of hacky, you could just try to open the file and see

open the file and see if it succeeded and then close it right away.

I wonder if there is a call code for just exists only.

I don’t remember off the top of my head.

So I’m going to remove it and then run the program again.

And then we should see now.

Yeah, now that the file didn’t exist and was newly created.

Now those new permissions that we added are reflected.

So the group, anybody who’s on the group can read and write.

And obviously the group is just the same as my new user by default.

But again, you could be more complicated than that.

you were running a multi-user system

and you wanted to share folders or whatever.

Okay, so I’m gonna remove output real fast

and I’m just gonna revert the permissions to 640

so that the group really can’t do very much

except just read it.

And then if I, oh shoot.

LS, okay, yeah.

So now you can see it reverted.

Okay, so we got the out file.

I’m starting to get lost here.

I’m starting to get lost here. What am I doing? I’m supposed to copy the data, I think. So file

tests and we are copying the file. I think I just uncommented that. Really? Oh, no, no, no. I’m

looking at my solution repo. Okay. That’s what I’m doing wrong. So we’ll look into your repo or your

the copy file I was like what how did I how did that program run if I already uncommented that

and we’ll we’ll uncomment this message for now no let’s leave it until we actually finish everything

so now we got to do the copy file function so where’s that okay I’m going to copy paste this

whole thing you know what this would have been like a five hour video if I actually had to type

this by hand I can’t even remember how long it took me to write this program I think it was like

off the top of my head. So this would be a nightmare to type, I think, on video, even if I

kind of already know how to do it now. So let’s see, string length, print an alternated string.

This is close file. This is create file. Okay, so I’m just going to do copy.

File is going to be right before close file and right after create file. Okay, so copy file.

Notice the signature that I’ve chosen for this one. It doesn’t return anything. So

So that’s like not great design.

You know, I need to check to see if the copying operations inside of my loop actually succeeded

and maybe return something to indicate success or failure or at least exit the program.

But I’m not doing that right now.

I’m just keeping it a little bit more simple.

It takes two arguments.

The first thing is the input handle and the second thing is the output handle.

Conveniently, we have both of those now at this point.

And then here’s my register usage.

through r15 to just sort of grab the incoming arguments here for r12 and 13 and then

r14 grabs the beginning of the temporary buffer which i’m going to make on the stack because i

think i’m so cool instead of making it as a global in the bss section and then uh

r15 is going to hold the result from the copy operation or i guess the the write operation so

Sorry, the read operation only.

Oh, I think I’m only checking the read bytes instead of the read and the write bytes.

I’ll talk about that in a second.

So I could upgrade my program a little bit more if I wanted to.

But basically R15 is going to be my temporary variable that looks at the return value to

say, hey, did we do we read anything?

Like how much did we read?

So copy file.

This is not a video about making local variables.

So just trust me on this.

so that I can use it to save the location of the stack pointer.

Then I’m going to make a copy buffer on the stack

just by subtracting the stack pointer

because the stack grows downward in memory location numbers.

And then the base pointer is going to help me remember

where the stack was when I started.

I’m just going to say that that’s going to be the first byte in my buffer.

And I’m going to move that into R14.

And let’s see, what did I do?

Let’s see, what did I do?

Think about from the stack.

Oh, did I write like a good program or a bad program?

I feel like I should have actually saved the base pointer and not the stack pointer there.

Let me see if this runs.

If it does run, I probably have a naughty program that might self-corrupt sometimes.

And it might be a good idea to move the base pointer as the first.

Because this is not a stack video, but basically the stack grows downward.

that means you’re sort of like extending its reach you’re allocating like a free space

if i take where the stack

nope nope nope i got it right i’m sorry if i take where the stack ends up after i extend it then i

have a lower address right because it grows downward to memory if i then say that the new

tip where it grew not where it grew from but where it grew to if i say that’s the first bite in a

in a buffer then when you’re actually using the buffer you increase memory locations as you’re

filling up a buffer so then that’s going to grow back towards where the stack started so it should

be fine i think if i if i did go ahead and reverse this if i used rbp instead of rsp there then i

think i would be going in the wrong direction and just corrupting memory so just so you know

this is not a stack video but just so you know so here’s a little label again i’m just kind of

iteration label and at the bottom I’m just kind of jumping back up to that label so this is a loop

you can imagine this is a while loop maybe I should draw that for fun I gotta find more excuses

to use my drophead so this is kind of like a while loop I’ll say while true maybe and here’s like the

body and then here’s like maybe the end of the body and so this jump statement just kind of goes back

this thing’s going to frustrate me so the first thing that happens is we read a portion

of the input file into the buffer so what are we doing we’re just using another system call

we’re saying let’s use the call code for read I can’t remember what that was it might have been

uh whoops oh I cleared the dang drawing oh hang on I have undo I think wait I have that I’m gonna

Okay, I’m not going to mess with it because this will actually terminate my whole program.

One of these keys, I forgot which one, will just kill the whole annotator.

So if we go up to SYS read in the defines, you can see that it is just call code zero.

So that means I’m telling the system I would like to read something.

First argument it wants is a file descriptor for the input file.

In a different video, I showed you how to use exactly this sort of thing to read standard

of thing to read standard input from the user or from another program that launched your program

but in this case r12 it’s not going to be the file handle zero for standard input it’s going

to be the actual file handle of the file that you’re trying to read from whatever that may have

been whatever the os gave you and then here here’s the address of where to store our characters and

if you look up again we decided to remember where the first byte in our buffer on the stack was or

like a local array like oh shoot let’s do it again let’s do more drawings you have like a function

right in c and then here it’s like we declared a local variable maybe not int maybe a character

array we’ll call it a or how about b for buffer and then we just gave it you know let’s say eight

bytes or something for the buffer i think i still have it set to two bytes obviously you want to use

more bytes for efficiency but just to prove that the loop actually works i’m keeping it small like

keeping it small like I said before whoa what’s all that you see that it’s like smearing okay

that’s not good so uh anyway we remembered where the uh buffer starts and it’s going to be r14

and then the copy buffer length is being you know used here uh and I think I have that set up to uh

from the input file and we want to read into our temporary buffer and we want to read at most

this many characters and then we say system call and it does all the work for us to read that many

characters and then we want to remember how many bytes were actually read because that could be

different from the number of bytes we requested maybe we’re at the end of the file maybe the

system is having like some kind of a buffer issue or something so we just want to remember how many

this little token up there to remind myself the temporary bytes read should

go there. Notice also that when we created the stack,

this is not a stack video again,

but like I made the stack buffer equal to the length of the buffer that I

actually wanted to use. So I use the same symbol,

copy buffer length and copy buffer length.

So then it’s going to try to figure out, okay,

how many bytes did we actually read? Let me,

let me do that while loop thing again. Cause I’m, I’m feeling it.

I’m feeling it.

feeling it did i really have to write the word true especially my bad penmanship so we’re doing

while true and then i’ll just say like read you know do some kind of a call to read maybe we’ll

say n equals read like a long you know the the r15 uh register is like the number of bytes that we

actually read and then we do a comparison here so we’re saying you know if you know n is um

if it’s equal to zero then we’re going to jump to the position in the while loop where we’re

um done which is actually past the while loop if you scroll down you’ll kind of see it so i’m just

going to say break so basically if we read zero bytes then we’re done reading bytes we’re just

finished so we just break the while loop and that’s what’s going to happen here when we say

the end of the body and you’ll see that in a second so then otherwise if we’re not done that

means execution is not going to jump it’s going to just fall through to the next statement here

and that’s going to be another system call code to write to the output file and it’s going to be

very similar we just load it up with the system call code for write let me just double check

is code one and then we’re going to give it the target for output which is going to be

a file handle so you know r13 r13 right here that’s a file handle that’s where we want to

write and then the next argument that it wants is the buffer and that’s going to be r14 which

is where we just what’s going on green grain there we go i’m having issues that’s uh the

that’s uh the buffer that we just read into right so if you look here r14 green oh my gosh okay so

green we uh read from uh the buffer pointed to by r14 and then we uh we read into the buffer

pointed to by r14 and then we are using that same buffer pointed to by r14 in order to grab

R15 says how many files or sorry, how many bytes?

Green, I’m having such problems.

R15 says how many bytes do you want to write to the file?

That should be our return value from before, right?

Because we want to read a certain number of bytes from the file

and then write exactly that many bytes.

If we did more, we would be writing some junk data probably.

And if we wrote less, then we would be missing data in the output file

that was originally in the input file.

So you want to do it exactly.

in the input file so you want to do it exactly and of course i’m just doing a system call here

but like i said before your program should probably be a little bit smarter and check

rax after you write to the file just to make sure that you know how many bytes were actually written

like what if you what if you read a hundred bytes but then you wrote 90 bytes only right that would

be like a bad situation so you’d want to do some branching logic there so that if you read 100 and

100 and you wrote 90 you probably want to backtrack the position of the file by like 10.

You know just to make sure that you can actually get all of the bytes into the output file

and seeking backwards 10 that’s just another system call. It’s not in this program but it’s

not too bad. You just make another system call give it the right call code tell it how far back

you want to go no problem. So then when by the time we make it here we’re going to jump back

We’re going to jump back up to the iterate label.

Let’s see, where’s that?

Yeah, right there.

We’re going to jump back up to the iterate label.

So basically this is how the while loop continues looping.

So let me clear that real fast.

Eventually when we’re out of data to read, you know, that’s because if we try to read

and we end up with zero bytes, that means we’re done.

We’ll break the while loop.

Then we’re going to go down here.

Notice how it says copy file done.

What I was talking about before, just sort of jumping past the end of the body.

so if we are done we jump to copy file done and all it does is just restore a

bunch of registers for us and then return to the caller so copy file we have that

handled now and if I go back up here file tests I guess I can I feel bad about

this I can uncomment the success message but we probably should have done more

checking on the reads and the rights just to make sure that we actually wrote

to make sure that we actually wrote the correct amount of characters and everything succeeded

every time and if not we exit the program and only if everything went well then we print a

successful message at this point in this program the way it’s written it could totally fail and

it’ll still say that it was successful so just keep that in mind that’s bad bad for your users

okay i think we have everything that we need now i can probably just run the program and

run. Notice now, oh shoot, I didn’t even show this to you before. Let me just emphasize this

one more time real fast. So I’m going to comment out the part where we actually copy the file

and I’m going to remove the output file. Then I’m going to run the whole program again. Notice how

the two MD5 sums are different. So remember before I said that MD5 sums, they’re basically

fingerprints. They’re not actually considered secure in the modern era. I just use them because

and fun if you are interested in security you probably want to use a

modern hashing algorithm so don’t use md5 but I am but don’t but I am and it’s

basically saying the fingerprint here of input is different than the fingerprint

here of the output quickly indicating to me that the files are different so if I

list the contents of the directory obviously that’s true because the output

file is empty still but if I uncomment this part here where I’m actually

here where I’m actually copying the file then I should see that the fingerprints

match and then if I look at what’s inside of the output file it should match

what’s inside of the input file really fast let me open up a terminal and I’ll

just cat the input file so this is all I added you know why hello there add some

stuff this is definitely more than two characters so we can be sure that our

buffer loop is actually working and so I’m gonna do clear and make run and now

And now the output file, notice how it has a matching file size.

It’s got 38 bytes in there.

Same thing for the input.

And then the thumbprints or, you know, the signatures, whatever you want to call it,

the hashes, they match exactly, indicating that we probably have two identical files.

Even with MD5, even though it’s old and not considered secure,

the chances of two files kind of having random differences,

not hacked differences, but just like random differences,

and having the same fingerprint is like astronomically almost impossible so if i do

cat input oops input.txt that’s what’s in there like we showed before and if i cat the output

now it is uh the same thing why hello there added some stuff for both i could make this as big as i

wanted to just for fun maybe let’s do uh let’s do a nano on the input file

I’ll just add like I don’t even know what I’m doing I’m just going to type a bunch of stuff

oh wait what is this remember that thing that people got taught a long time ago it was like

the quick brown fox jumped over the lazy dog and this was supposed to be all the letters of the

alphabet there was an there’s another one that I just heard about and I don’t remember exactly

look it up on the internet it’s it’s pretty cool i think i need to memorize this and stop using the

lazy dog it was um something like those sphinx of quartz hear my vow or something like that

you know what i’m gonna look it up for you right now i don’t want to do the wrong thing

it’s really cool uh i’ll type brown fox and then uh

Hear my vow.

Oh, Sphinx of black quartz.

Judge my vow.

That’s what it is.

Okay, so I’m going to go back to my little VM here.

Sphinx of black quartz.

Judge my…

I didn’t even write vow correctly.

Judge my vow.

And I think that has all the letters in the alphabet too.

probably less spaces. I wonder if that’s, I mean, that’s what the internet says. If this is true,

and it has all the letters of the alphabet, that’s going to be awesome. I’m going to memorize that

for sure. Sphinx of black quartz, judge my vow. Anyway, so I’m just kind of adding stuff into

this file. And if I run, let me save that here. I’ll do a clear. And then I’ll do, um,

I’ll cat the input file here, and then cat the output file. So you can see they’re different.

again let me remove the output file just in case I can’t remember if I’m supposed

to remove it manually or if I put that into the program we’ll just try it like

this so now they match and then if I cat again the output file notice how it’s a

perfect copy of the input file nice so I think that’s pretty much everything

that I wanted to show you maybe um well maybe we can use a more efficient buffer

we can use a more efficient buffer now that it’s done the copy buffer we could change this to like

eight kilobytes or something we should end up with the same result let me run this just as is

and see if it ends up being the same thing without erasing the file first yeah it looks good let me

remove the output file and then run it one more time so make run and then uh cat the output file

yeah okay so it still works but um you know whereas before we were just using a two byte buffer

two byte buffer there’s like very little chance except maybe at the end of the file that we would

request more data than the file had but using the return value of the read operation always told us

exactly how much was read by the operating system on the other hand if we have a giant buffer we

could request way more bytes than the file could ever have because that file is way less than eight

kilobytes so again we still want to look at the return value to make sure we know how many bytes

how many bytes should be sent into the right file.

So I guess that’s everything that I wanted to tell you

about reading and writing files using system calls.

I hope you’ve learned a lot of stuff

and you enjoyed this video and had a little bit of fun.

Thank you so much for watching.

I’m going to cut the video.

I’ll see you, whoops.

I’ll see you in the next video.

Hey everybody.

Thanks for watching this video again

from the bottom of my heart.

I really appreciate it.

I do hope you did learn something

I do hope you did learn something and have some fun

If you could do me a please a small little favor. Could you please subscribe and follow this channel or these videos or

Whatever it is you do on the current social media website that you’re looking at right now

It would really mean the world to me and it’ll help make more videos and grow this community

So we’ll be able to do more videos longer videos better videos or just I’ll be able to keep making videos in general

So please do do me a kindness and and subscribe

and subscribe. You know sometimes I’m sleeping in the middle of the night and

I just wake up because I know somebody subscribed or followed. It just wakes me

up and I get filled with joy. That’s exactly what happens every single time.

So you could do it as a nice favor to me or you could you control me if you want

to just wake me up in the middle of the night just subscribe and then I’ll just

wake up. I promise that’s what will happen. Also if you look at the middle of

the screen right now you should see a QR code which you can scan in order to go

to the website which I think is also named somewhere at the bottom of this

also named somewhere at the bottom of this video and it’ll take you to my main website where you

can just kind of like see all the videos I published and the services and tutorials and

things that I offer and all that good stuff and uh if you have a suggestion for uh uh clarifications

or errata or just future videos that you want to see please leave a comment or if you just want to

say hey what’s up what’s going on you know just send me a comment whatever I also wake up for

I wake up in a cold sweat and I’m like,

it would really mean the world to me.

I would really appreciate it.

So again, thank you so much for watching this video

and enjoy the cool music as I fade into the darkness,

which is coming for us all.

Thank you.

The post Master File Copying with System Calls in x86-64 YASM Assembly appeared first on NeuralLantern.com.