Go Red Team Development—File Operation

File Operation

Since there is an operation requirement for files in the previous issue of codec, this issue adds file operation function.
Still put the code directly to speed up the learning progress, and just use the code as you hold it. They are all built-in functional functions.

PS: Some function parameters or function explanations are placed in code comments

Create a directory

// Create a directory

 func createDir() {

     err := ("test_dir", )

 if err != nil {

 ("Create directory failed")

           return

     }

 ("Create directory successfully")

 }

Create a file

// Create a file

 func createFile(filename string) {

 newfile, err := (filename)

 defer ()

 if err != nil {

 ("File creation failed:", err)

           return

     }
 ("File creation successfully:", ())

 }

Get File information

Both files and directories can be judged

func getFileInfo() {

 //path := "test_dir"

 path := ""

 fileInfo, err := (path)

 if err != nil {

 (err)

           return

     }

     ("file name:", ())

 ("File Size:", ())

 ("File Permissions:", ())

 ("Last modified time:", ())

 ("Is it a directory: ", ())

 //("System interface type: %T", ())

 //("System information: %+v", ())

 }

File renaming

// File rename

 func renameFile() {

 oldFileName := ""

 newFileName := ""

 err := (oldFileName, newFileName)

 if err != nil {

 ("Rename error:", err)

           return

     }

 }

Delete files

// Delete the file

 func removeFile(fileaName string) {

 err := (fileaName)

 if err != nil {

 ("Deletion failed:", err)

           return

     }

 (fileaName, "Delete Successfully")

 }

Open and close the file

// Open and close the file

 //Introduction to the original open file and OpenFile can provide more options to open files

 func open_close_file() {

  

 ("Open File")

 file, err := ("")

 defer () //Delayed closing of the file. It is recommended to write one habitually after opening the file.

 if err != nil {

 ("Failed to open the file:", err)

           return

     }

 ("File opened successfully")

     //---------------------------------------------

 ("Open File")

 file, err = ("", os.O_CREATE|os.O_APPEND|os.O_RDWR, 0666)

 defer ()

 if err != nil {

 ("Failed to open the file:", err)

           return

     }

 ("Open file successfully")

 }

Determine whether the file exists

// Determine whether the file exists

 func isExistFile(fileName string) {

       _, err := (fileName)

 if err != nil {

 //There may be many reasons for reporting an error. If you want to know if the file does not exist, you still need to verify it.

 if (err) {

 ("Confirm this error is caused by the file not exists:", err)

           }

  

     }

 }

Determine whether the file has read permission

// Determine whether the file has read and write permissions

 func isPermission() {

  

 file, err := ("", os.O_RDONLY, 0666) //Take the O_WRONLY flag directly to determine whether you have write permissions

 defer ()

 if err != nil {

 if (err) {

 ("No read permission:", err)

           }

     }

 ("Readable")

  

 file, err = ("", os.O_WRONLY, 0666) //Take the O_WRONLY flag directly to determine whether you have write permissions

 defer ()

 if err != nil {

 if (err) {

 ("No write permission", err)

           }

     }

 ("Writable")

  

 }

Copy the file

// File copy

 func copyFile() {

  

 //Open a file you want to copy

     src_file, src_err := ("")

 defer src_file.Close()

 if src_err != nil {

 ("File opening failed:", src_err)

     }

  

 //Create a new file to copy the content here (in fact, you can continue to open it with existing files, mainly using file handles)

 des_file, des_err := ("")

 defer des_file.Close()

 if des_err != nil {

 ("File creation failed", des_err)

     }

  

 //Copy content into a new file

 bytesWritten, err := (des_file, src_file) //bytesWritten is to calculate the length of the copy

 if err != nil {

 ("Copy failed:", err)

     }

 ("Written:", bytesWritten)

  

 // Flush the file contents to the hard disk. This operation is unnecessary for us now.

 // Because in most cases, when the program exits normally, the data will be automatically refreshed to disk by the operating system.

 // When we are constantly writing content, we may need to flush regularly

 err = des_file.Sync()

 }

Read

// ---------------------------------------------------

 // Read file content

 // ---------------------------------------------------

 // Read reads the file content and returns the read length and content. If the read length is less than the length of the slice, it means that the file has been read.

 func readFile() {

 //Open the file

 file, err := ("", os.O_RDWR, 0666)

 defer ()

 if err != nil {

 ("Failed to open the file:", err)

           return

     }

 bytes_content := make([]byte, 10)           //Read is to pass the content into this slice space

 contentlen, err := (bytes_content) //Returns the length of the read

 if err != nil {

 ("Read file failed:", err)

           return

     }

 ("Read length: %d\n", contentlen)

 ("Read content:", string(bytes_content))

 }

ReadFull read

// ReadFull reads the file content, returning the read length and content. If the read length is less than the length of the slice, it will return an error

 func readFullFile() {

 //Open the file

 file, err := ("", os.O_RDWR, 0666)

 defer ()

 if err != nil {

 ("Failed to open the file:", err)

           return

     }

  

 //ReadFull is to pass content into this bytes_content slice space. If the space given is greater than the read content, an error will be reported. If it is less than, it will be read as much as possible.

 bytes_content := make([]byte, 2)

 contentlen, err := (file, bytes_content) //Returns the length of the read

 if err != nil {

 ("Read file failed:", err)

           return

     }

 ("Read length: %d\n", contentlen)

 ("Read content:", string(bytes_content))

 }

ReadAtLeast Read

// ReadAtLeast at least reads the content of the xx bytes file

 func readAtLeastFile() {

 //Open the file

 file, err := ("", os.O_RDWR, 0666)

 defer ()

 if err != nil {

 ("Failed to open the file:", err)

           return

     }

 bytes_content := make([]byte, 512) //Read is to pass content into this slice space

  

 // () will return an error when the smallest byte content cannot be obtained.

 // If you don't return,

 // He will keep the read files.  You can still print what you read

 //Compared with ReadFull, ReadAtLeast will not report an error.

 // Just say that the minimum number of bytes is at least read so many.

 // But it will still be read later, and an error will leave the read content

 minBytes := 10

 contentlen, err := (file, bytes_content, minBytes) //Returns the length of the read

 if err != nil {

 ("Read file failed:", err)

 //return   //Cancel return, you can still print the read content

     }

 ("Read length: %d\n", contentlen)

 ("Read content:", string(bytes_content))

 }

ReadAll read

// ReadAll reads all contents of the file

 func readAllFile() {

 //Open the file

 file, err := ("", os.O_RDWR, 0666)

 defer ()

 if err != nil {

 ("Failed to open the file:", err)

           return

     }

 // () will read all file contents, and the length returned is the read

 content, err := (file) //Returns the length of the read

 if err != nil {

 ("Read file failed:", err)

           return

     }

 ("Read content:", string(content))

 }

bufio read

The following isSpecific descriptions and examples of several commonly used splitters:

---

• Splitting characters: Space ( ) or continuous whitespace characters (including spaces, tab characters\t, line break\nwait).
• Behavior: Scan one word at a time (a string separated by whitespace characters).
• Example:

  ()
  

  enter:

  "Hello   World\nGo Programming"
  

  Output:

  "Hello"
  "World"
  "Go"
  "Programming"
  

---

• Splitting characters: newline character (\n）。
• Behavior: Scan one line at a time (a string separated by a newline).
• Example:

  ()
  

  enter:

  "Hello\nWorld\nGo Programming"
  

  Output:

  "Hello"
  "World"
  "Go Programming"
  

---

• Splitting characters: None (segmented by bytes).
• Behavior: One byte is scanned at a time.
• Example:

  ()
  

  enter:

  "Hello"
  

  Output:

  'H'
  'e'
  'l'
  'l'
  'o'
  

---

• Splitting characters: None (segmented by character).
• Behavior: One character is scanned at a time (multi-byte characters are supported, such as Chinese).
• Example:

  ()
  

  enter:

  "Hello World!"

  Output:

  'you'
   'good'
   ','
   'World'
   'boundary'
   '!  '

---

Summarize

Segmentation function	Splitting characters	Behavior	Sample input	Sample output
	Space( ) or continuous whitespace characters	Scan one word at a time	"Hello World\nGo"	"Hello", "World", "Go"
	Line breaks (\n）	One line is scanned at a time	"Hello\nWorld\nGo"	"Hello", "World", "Go"
	none	One byte is scanned at a time	"Hello"	'H', 'e', 'l', 'l', 'o'
	none	One character is scanned at a time (multi-byte characters are supported)	"Hello World!"	'you', 'good', '，', 'World', 'boundary', '！'

---

Things to note

1. :

   • Continuous whitespace characters (such as multiple spaces or tabs) are ignored.
   • Suitable for processing space-separated text.

2. :

   • The contents of each line (including whitespace characters at the end of the line) will be retained.
   • Suitable for processing line-by-line text.

3. :

   • Segmented by bytes, suitable for processing binary data or scenarios that require byte-byte analysis.

4. :

   • Split by character and supports multi-byte characters (such as Chinese, Japanese, Korean, etc.).
   • Suitable for handling Unicode text.

Sample code:

// Bufio read files can be read line by line with scanner, which may be used most during security development, because the requirements for blasting are generally read line by line.

 func bufioReadFile() {

 //Open the file

 file, err := ("", os.O_RDWR, 0666)

 defer ()

 if err != nil {

 ("Failed to open the file:", err)

           return

     }

 //() returns an object that can be used to read file contents

     reader := (file)

 //() returns an object that can be used to read file contents

     scanner := (reader)

     //() //Split by spaces

 //() //Segment by newline characters. If you don't write by default, you will be divided by newline characters.

     //() //Split by bytes

     //() //Split by character

 for () {

 (())

     }

 }

Write write

// ---------------------------------------------------

 // Write file contents

 // ---------------------------------------------------

 func write() {

 file, err := (

 "",

 os.O_CREATE|os.O_APPEND|os.O_RDWR|os.O_APPEND,

         0666,

     )

 defer ()

 if err != nil {

 ("File opening failed:", err)

           return

     }

 bytesWrittenLen, err := ([]byte("hello hack\n"))

 if err != nil {

 ("Content writing failed:", err)

           return

     }

 ("Write successful: %d byte length\n", bytesWrittenLen)

 }

WriteFile Quick Write

// Write content quickly

 // Used when writing content quickly and concisely

 func ioutil_WriteFile() {

     err := ("", []byte("hello hack2\n"), 0666)

 if err != nil {

 ("Content writing failed:", err)

           return

     }

  

 }

Temporary file directory

// Temporary files and directories may be used when developing tools

 func tmpDir_File() {

 // The first parameter is an empty string that indicates that TempDir will use the system's default temporary directory.

 // On Linux/macOS, usually /tmp.

 // On Windows, it is usually C:\Users\<User>\AppData\Local\Temp.

     tempDir, err := ("", "tmpDirName")

 if err != nil {

 ("Creation failed:", err)

           return

     }

 ("Directory creation successfully:", tempDir)

  

     tempFile, err := (tempDir, "") //Create a file to give parameters: tempDir directory and temp file name

 if err != nil {

 ("File creation failed:", err)

           return

     }

 ("File creation successfully:", ())

  

 //Although it is a temporary file, it can manually close the file

 defer ()

  

     err = (())

 if err != nil {

 ("File deletion failed")

           return

     }

  

     err = (tempDir)

 if err != nil {

 ("Directory deletion failed")

           return

     }

  

 }

Download the file

// http get downLoad file to local

 func downLoadFile() {

 httpFile, err := (

 "",

 os.O_CREATE|os.O_RDWR,

         0666,

     )

 if err != nil {

 ("File opening failed")

     }

 defer ()

     url := ""

 rep, err := (url)

 defer ()

  

 written, err := (httpFile, )

 if err != nil {

 ("File copy failed:", err)

     }

 ("Download successfully, file size (byte):\n", written)

 }

File pointer operation

func offsetFile() {

 //Open the file

 file, err := ("", os.O_RDWR, 0666)

 defer ()

 if err != nil {

 ("Failed to open the file:", err)

           return

     }

 //Get the offset of the file

 var (

 offset int64 = 1

 when int = 1

  

 //Whence is used to calculate the position of offset

 // 0 = file start location

 // 1 = Current location

 // 2 = At ​​the end of the file

     )

 newP, err := (offset, when)

 if err != nil {

 ("Failed to obtain file offset:", err)

           return

     }

 ("File Offset:", newP)

 //Read the file content directly at the current location

 bytes_content := make([]byte, 10)           //Read is to pass the content into this slice space

 contentlen, err := (bytes_content) //Returns the length of the read

 if err != nil {

 ("Read file failed:", err)

           return

     }

 ("Read length: %d\n", contentlen)

 ("Read content:", string(bytes_content))

  

 }

Modify file permissions/owner/timestamp

Reference article: /2016/10/12/go-file-operations/
This is really good written by the author of this article, and it is all practical information.

package main

 import (

     "log"

     "os"

     "time"

 )

 func main() {

     // Change file permissions using Linux style

     err := ("", 0777)

     if err != nil {

         (err)

     }

     // Change the file owner

     err = ("", (), ())

     if err != nil {

         (err)

     }

     // Change the timestamp

     twoDaysFromNow := ().Add(48 * )

     lastAccessTime := twoDaysFromNow

     lastModifyTime := twoDaysFromNow

     err = ("", lastAccessTime, lastModifyTime)

     if err != nil {

         (err)

     }

 }

Supplementary knowledge details

Let me first introduce this openfile function. I used it to open files before, but I can only open files in a read-only manner. The more common file opening function of openfile can specify the opening mode (read-only, write-only, read-write, etc.) and file permissions. Next, I will use openfile to operate files and control files more refinedly.

File opening mode flag, what mode should be used to open the file when using openfile

for example:("", os.O_RDWR|os.O_CREATE|os.O_APPEND, 0644)
Multiple forms can be separated by the |pipe symbol, indicating that they are readable and writable. At the same time, CREATE means that they are created when the file does not exist, and APPEND means that they are appended.
For more modes, please see the following introduction

os.O_RDONLY: Open the file in read-only mode. 
 os.O_WRONLY: Open the file in write-only mode. 
 os.O_RDWR: Open the file in read and write mode. 
 os.O_APPEND: Append mode.  If the file already exists, data will be written to the end of the file. 
 os.O_CREATE: Create a file if it does not exist. 
 os.O_EXCL: Used with os.O_CREATE, the file must not exist. 
 os.O_SYNC: Synchronize I/O to ensure that the written data and metadata are synchronized to the storage device.
 os.O_TRUNC: If the file already exists, truncate its degree to zero when opened.

---

Details are written first: After we finish reading or writing, the file pointer is not at the beginning. If you finish reading, write directly, write it at the current location you read, or continue reading after writing, read it at the current location, and may not be able to read what you want, so it is very necessary, or if you reopen the file, you can automatically point the pointer to the beginning.

---

Demo code:
Open a file to writehello hack, and then read the contents of this file

• O_RDWR:Readable or writeable
• O_CREATE: Create if the file does not exist
• O_APPEND:Add mode
• The last 0666 is file operation permissions, which involves the issue of file permissions for Linux (ignored, talked about later)

func write_readTest() {

 file, err := ("", os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)

 defer ()

 if err != nil {

 (err)

           return

     }

 ("hello hack") // Write to the file

 // Read the file

 scanner := (file)

  

 //After reading the file, the file pointer has reached the end of the file and needs to be relocated to the beginning of the file

 // Relocate the file pointer to the beginning of the file

 (0, 0)

 for () {

 (()) //Read one line by one

     }

 if err := (); err != nil {

 ("Read file failed:", err)

     }

  

 }

---

bufio

We used this when we coded itbufio, we can new a scanner to read the file content one by one. If you need more fine-grained control (such as reading by byte), you can use。

//Common methods
 file, err := ("", os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
	 // Read the file
 scanner := (file)
 for () {
 (()) //Read one line by one

     }
 if err := (); err != nil {
 ("Read file failed:", err)
     }

It is a function used in Go language to obtain file or directory information. Its function is to return an object describing the status of a file or directory (）

• Parametersname:

  • Accepts a string parameter that represents the path to a file or directory.

  • It can be a relative path (such as"../ or directory ../dirname") or absolute path (such as"/home/user/"）。

  • It can also be the file name (if the file is in the current working directory).

• Return value:

  • FileInfo: An interface type that contains detailed information about a file or directory.

  • error: If the operation fails (if the file does not exist), an error message is returned.

is an interface that contains the following methods:

Method name	Return value type	illustrate
Name() string	string	Returns the name of the file or directory (excluding paths).
Size() int64	int64	Returns the byte size of the file (the directory usually returns 0).
Mode() FileMode	FileMode	Returns the permissions and mode of the file.
ModTime()		Returns the last modification time of the file.
IsDir() bool	bool	Determine whether it is a directory.
Sys() interface{}	interface{}	Return the underlying data source (usuallynil）。

File permissions

Use ⋯-digit numbers to represent the permissions of files. Here is the knowledge of Linux file permission management, and you don’t know how to check yourself.

: Default permissions for files (0777)

: represents a directory. 
 : means that the file can only be added to the file. 
 : means that the file is exclusive. 
 : means that the file is a temporary file. 
 : means that the file is a symbolic link. 
 : means that the file is a device file. 
 : means that the file is a named pipe. 
 : Indicates that the file is a Unix domain socket. 
 : means that the file has the setuid bit. 
 : means that the file has the setgid bit. 
 : means that the file is a character device. 
 : means that the file has sticky bits. 
 : means that the file is an irregular file.

Reference article:/2016/10/12/go-file-operations