Introduction
Security engineers make use of Unix or Linux systems for the majority of their tasks. A popular feature with such systems is how everything is treated as a file. Files, processes, directories, sockets and even connected devices are treated as files. This holds true for virtually everything in the computer ecosystem. Consequently, a security engineer using Golang must be able to manage files effectively with the language. In this article, file management with Google’s Go Programming Language (Golang) is explained. The article expounds on the process of creating, truncating, deleting, opening, closing, renaming, and moving files comfortably in Golang. Accessing and manipulating file properties is also addressed in this article.
Creating New Files
Creating a new file is relatively easy on the terminal, but there may be need to directly transfer data collected to a file in-code. Similar to the touch command in a Linux terminal, a new file can be created with Golang like this:
package main
import (
"log"
"os"
)
func main() {
cre8, err := os.Create("cre8.txt")
if err != nil {
log.Fatal(err)
}
log.Println(cre8)
cre8.Close()
}
One major feature that sets Go apart from other modern languages is its ability to handle possible errors during code time. This practices saves the Go developer from running into compiler errors every do often, from creating bugs, and guarantees the developer more productive time.
Truncating Files
File truncation means attenuating a file by restricting it to a preferred maximum size. If the file is smaller that the specified truncate limit, the os.Truncate method will instead increase the file size to fit. Truncation is explained by code below in limiting a file.
package main
import (
"log"
"os")
func main() {
err := os.Truncate("cre8.txt", 100)
if err != nil {
log.Fatal(err)
}
}
The example code above truncates the file to a 100 byte file. If the file is below 100 bytes, the compiler writes enough lines of null bytes to the bottom of the file. If the file is above 100 bytes, the compiler trims away everything above the 100th bite.
Accessing File Properties
The os package also has a Stat method for fetching the attributes of a file. This may be it’s name, size, permissions, last modified time, and whether it is adirectory.
There is also the FileInfo.Sys() interface which contains information about the source of the file. The file source is usually a file system on the harddisk.
package main
import (
"fmt"
"os"
"log"
)
func main() {
fileInfo, err := os.Stat("cre8.txt")
if err != nil {
log.Fatal(err)
}
fmt.Println("File name:", fileInfo.Name())
fmt.Println("Size in bytes:", fileInfo.Size())
fmt.Println("Permissions:", fileInfo.Mode())
fmt.Println("Last modified:", fileInfo.ModTime())
fmt.Println("Is Directory: ", fileInfo.IsDir())
fmt.Printf("System interface type: %T\n", fileInfo.Sys())
fmt.Printf("System info: %+v\n\n", fileInfo.Sys())
}
Opening and Closing Files
To open a file and/or close it, the os.Open() and os.Close() methods are used. To get more options and privileges after opening the file, the os.OpenFile() method may be used instead. The code sample below shows how both are done in Go.
package main
import (
"log"
"os"
)
func main() {
file, err := os.Open("cre8.txt")
if err != nil {
log.Fatal(err)
}
file.Close()
file, err = os.OpenFile("cre8.txt", os.O_APPEND, 0666)
if err != nil {
log.Fatal(err)
}
file.Close()
}
Reading and Writing to Files
The owner of a file may find the need to change the ownership, timestamp, and permissions. To do so in Go, a number of functions exist in the os package like
os.Chmod()os.Chown()os.Chtimes()
To practically understand their use case in Go, see the code sample below.
package main
import (
"log"
"os"
"time"
)
func main() {
err := os.Chmod("cre8.txt", 0777)
if err != nil {
log.Println(err)
}
err = os.Chown("cre8.txt", os.Getuid(), os.Getgid())
if err != nil {
log.Println(err)
}
// Change timestamps
twoDaysFromNow := time.Now().Add(48 * time.Hour)
lastAccessTime := twoDaysFromNow
lastModifyTime := twoDaysFromNow
err = os.Chtimes("cre8.txt", lastAccessTime, lastModifyTime)
if err != nil {
log.Println(err)
}
}
Renaming and Deleting Files
Renaming and moving file are synonymous terms in Go. As such, these operations are done with one method - os.Rename().
package main
import (
"log" "os"
)
func main() {
original := "cre8.txt"
new := "cre8ed.txt"
err := os.Rename(original, new)
if err != nil {
log.Fatal(err)
}
}
This also works for renaming or moving directories.
To delete files, the os.Remove() method is used.
package main
import (
"log"
"os"
)
func main() {
err := os.Remove("test.txt")
if err != nil {
log.Fatal(err)
}
}
Archiving and Compressing Files
Archiving a file means saving it and other files into a folder and zipping it. Go’s archive package allows the programmer to either zip or far files. An example of the use-case is seen below.
package main
import (
"archive/zip"
"log"
"os"
)
func main() {
outFile, err := os.Create("cre8.zip")
if err != nil {
log.Fatal(err)
}
defer outFile.Close()
zipWriter := zip.NewWriter(outFile)
var filesToArchive = []struct {
Name, Body string
}{
{"test.txt", "String contents of file"},
{"test2.txt", "\x61\x62\x63\n"},
}
for _, file := range filesToArchive {
fileWriter, err := zipWriter.Create(file.Name)
if err != nil {
log.Fatal(err)
}
_, err = fileWriter.Write([]byte(file.Body))
if err != nil {
log.Fatal(err)
}
}
err = zipWriter.Close()
if err != nil {
log.Fatal(err)
}
}
To compress files, Go has several functions for several kinds of file formats. These are available in the compress package in the standard documentation.
package main
import (
"compress/gzip"
"log"
"os"
)
func main() {
err := os.Create("cre8.txt.gz")
if err != nil {
log.Fatal(err)
}
gzipWriter := gzip.NewWriter(outputFile)
defer gzipWriter.Close()
_, err = gzipWriter.Write([]byte("Gophers rule!\n"))
if err != nil {
log.Fatal(err)
}
log.Println("Compressedbdata written to file.")
}
There are lots of other possible actions that can be achieved in file management with Golang. Reading through the standard library documentation for the os and ioutil packages would expose a lot of them.
A series of follow-up articles will be published on Security related practices.
My name is MacBobby Chibuzor and I am a Software Engineer and Technical Writer for Wevolver. I research and write about Blockchain, Security, Web Development, Data Structures and Algorithms, Machine Learning and IoT.