Picocrypt/cli/v2/picocrypt/main.go

677 lines
15 KiB
Go

package main
import (
"archive/zip"
"bytes"
"crypto/cipher"
"crypto/hmac"
"crypto/rand"
"flag"
"fmt"
"hash"
"io"
"math"
"os"
"os/signal"
"path/filepath"
"strconv"
"strings"
"time"
"github.com/HACKERALERT/infectious"
"github.com/HACKERALERT/serpent"
"github.com/schollz/progressbar/v3"
"golang.org/x/crypto/argon2"
"golang.org/x/crypto/blake2b"
"golang.org/x/crypto/chacha20"
"golang.org/x/crypto/hkdf"
"golang.org/x/crypto/sha3"
"golang.org/x/term"
)
var f *bool
var k *bool
var p *bool
var r *bool
var mode string
func parse() int {
flag.Usage = func() {
fmt.Println("Usage: picocrypt <item1> [<item2> ...]")
fmt.Println("Items: can be files, folders, or globs")
fmt.Println("Flags:")
flag.PrintDefaults()
os.Exit(1)
}
f = flag.Bool("f", false, "(decryption) attempt to fix corruption")
k = flag.Bool("k", false, "(decryption) keep output even if corrupted")
p = flag.Bool("p", false, "(encryption) use paranoid mode")
r = flag.Bool("r", false, "(encryption) encode with Reed-Solomon")
flag.Parse()
if flag.NArg() == 0 {
flag.Usage()
}
for _, v := range flag.Args() {
if strings.HasPrefix(v, "-") {
fmt.Println("Flags must be provided before arguments!")
return 1
}
}
if flag.NArg() == 1 {
if strings.HasSuffix(flag.Arg(0), ".pcv") {
mode = "decrypt"
} else {
mode = "encrypt"
}
} else {
mode = "encrypt"
for _, v := range flag.Args() {
if strings.HasSuffix(v, ".pcv") {
fmt.Println("Multiple items must not contain volumes.")
return 1
}
}
}
return 0
}
var password []byte
var confirmp []byte
var err error
func auth() int {
if mode == "encrypt" {
fmt.Print("Password: ")
password, err = term.ReadPassword(int(os.Stdin.Fd()))
if err != nil {
fmt.Println("Error reading password!")
return 1
}
fmt.Print(strings.Repeat("*", len(password)), " | Confirm: ")
confirmp, err = term.ReadPassword(int(os.Stdin.Fd()))
if err != nil {
fmt.Println("Error reading password!")
return 1
}
fmt.Println(strings.Repeat("*", len(confirmp)))
if !bytes.Equal(password, confirmp) {
fmt.Println("Passwords don't match!")
return 1
}
} else {
fmt.Print("Password: ")
password, err = term.ReadPassword(int(os.Stdin.Fd()))
if err != nil {
fmt.Println("Error reading password!")
return 1
}
fmt.Println(strings.Repeat("*", len(password)))
}
return 0
}
var pin string
var pout string
var pzip string
var file *os.File
var writer *zip.Writer
var files []string
var interrupted bool
func prepare() int {
if mode == "decrypt" {
pin = flag.Arg(0)
pout = strings.TrimSuffix(pin, ".pcv")
} else {
stat, err := os.Stat(flag.Arg(0))
if flag.NArg() == 1 && err == nil && !stat.IsDir() {
pin = flag.Arg(0)
pout = pin + ".pcv"
} else {
items := []string{}
for _, v := range flag.Args() {
if strings.Contains(v, "../") || strings.HasPrefix(v, "/") {
fmt.Println("Cannot encrypt outside of current directory.")
return 1
}
matches, err := filepath.Glob(v)
if err != nil {
fmt.Println("Invalid glob pattern:", v)
return 1
}
items = append(items, matches...)
}
for _, v := range items {
stat, err := os.Stat(v)
if err != nil {
fmt.Println("Cannot access input:", v)
return 1
}
if !stat.IsDir() {
files = append(files, v)
} else {
filepath.Walk(v, func(path string, _ os.FileInfo, _ error) error {
stat, err := os.Stat(path)
if err == nil && !stat.IsDir() {
files = append(files, path)
}
return nil
})
}
}
if len(files) == 0 {
fmt.Println("Nothing to encrypt!")
return 1
}
}
}
return 0
}
func compress() int {
if files == nil {
return 0
}
dir, err := os.Getwd()
if err != nil {
fmt.Println("Cannot get current working directory!")
return 1
}
dir = filepath.ToSlash(dir)
file, err = os.CreateTemp("", "picocrypt-cli-v2-*.tmp")
if err != nil {
fmt.Println("Cannot create temporary file!")
return 1
}
pzip = file.Name()
writer = zip.NewWriter(file)
for i, path := range files {
stat, err := os.Stat(path)
if err != nil {
continue
}
header, err := zip.FileInfoHeader(stat)
if err != nil {
continue
}
abs, err := filepath.Abs(path)
if err != nil {
continue
}
abs = filepath.ToSlash(abs)
header.Name = strings.TrimPrefix(abs, dir)
header.Name = strings.TrimPrefix(header.Name, "/")
header.Method = zip.Deflate
entry, err := writer.CreateHeader(header)
if err != nil {
continue
}
fin, err := os.Open(path)
if err != nil {
writer.Close()
file.Close()
fmt.Println("Read access to input denied:", path)
return 1
}
bar := progressbar.NewOptions(
int(stat.Size()),
progressbar.OptionClearOnFinish(),
progressbar.OptionFullWidth(),
progressbar.OptionShowBytes(true),
progressbar.OptionUseIECUnits(true),
progressbar.OptionSetDescription(
fmt.Sprintf("Compressing [%d/%d]:", i+1, len(files)),
),
)
_, err = io.Copy(io.MultiWriter(entry, bar), fin)
fin.Close()
if err != nil {
if interrupted {
time.Sleep(1 * time.Second)
} else {
writer.Close()
file.Close()
fmt.Println("Insufficient disk space!")
return 1
}
}
}
writer.Close()
file.Close()
pin = file.Name()
pout = "encrypted-" + strconv.Itoa(int(time.Now().Unix())) + ".zip.pcv"
return 0
}
var fin *os.File
var fout *os.File
var padded bool
var salt []byte
var hkdfSalt []byte
var serpentIV []byte
var nonce []byte
var keyHash []byte
var keyHashRef []byte
var authTag []byte
var key []byte
var mac hash.Hash
var MiB = 1 << 20
var GiB = 1 << 30
var rs5, _ = infectious.NewFEC(5, 15)
var rs16, _ = infectious.NewFEC(16, 48)
var rs24, _ = infectious.NewFEC(24, 72)
var rs32, _ = infectious.NewFEC(32, 96)
var rs64, _ = infectious.NewFEC(64, 192)
var rs128, _ = infectious.NewFEC(128, 136)
func rsEncode(rs *infectious.FEC, data []byte) []byte {
res := make([]byte, rs.Total())
rs.Encode(data, func(s infectious.Share) {
res[s.Number] = s.Data[0]
})
return res
}
func rsDecode(rs *infectious.FEC, data []byte, fast bool) ([]byte, error) {
if rs.Total() == 136 && fast {
return data[:128], nil
}
tmp := make([]infectious.Share, rs.Total())
for i := 0; i < rs.Total(); i++ {
tmp[i].Number = i
tmp[i].Data = append(tmp[i].Data, data[i])
}
res, err := rs.Decode(nil, tmp)
if err != nil {
if rs.Total() == 136 {
return data[:128], err
}
return data[:rs.Total()/3], err
}
return res, nil
}
func pad(data []byte) []byte {
padLen := 128 - len(data)%128
padding := bytes.Repeat([]byte{byte(padLen)}, padLen)
return append(data, padding...)
}
func unpad(data []byte) []byte {
padLen := int(data[127])
return data[:128-padLen]
}
func work() int {
fin, err = os.Open(pin)
if err != nil {
fmt.Println("Error accessing input file:", pin)
return 1
}
_, err = os.Stat(pout)
if err == nil {
fmt.Println("Output file already exists!")
return 1
}
fout, err = os.Create(pout)
if err != nil {
fmt.Println("Error creating output file:", pout)
return 1
}
stat, err := os.Stat(pin)
if err != nil {
fmt.Println("Error accessing input file:", pin)
return 1
}
total := stat.Size()
if mode == "decrypt" {
total -= 789
}
if mode == "encrypt" {
errs := make([]error, 10)
salt = make([]byte, 16)
hkdfSalt = make([]byte, 32)
serpentIV = make([]byte, 16)
nonce = make([]byte, 24)
_, errs[0] = fout.Write(rsEncode(rs5, []byte("v1.34")))
_, errs[1] = fout.Write(rsEncode(rs5, []byte("00000")))
flags := make([]byte, 5)
if *p {
flags[0] = 1
}
if *r {
flags[3] = 1
}
if total%int64(MiB) >= int64(MiB)-128 {
flags[4] = 1
}
_, errs[2] = fout.Write(rsEncode(rs5, flags))
rand.Read(salt)
rand.Read(hkdfSalt)
rand.Read(serpentIV)
rand.Read(nonce)
_, errs[3] = fout.Write(rsEncode(rs16, salt))
_, errs[4] = fout.Write(rsEncode(rs32, hkdfSalt))
_, errs[5] = fout.Write(rsEncode(rs16, serpentIV))
_, errs[6] = fout.Write(rsEncode(rs24, nonce))
_, errs[7] = fout.Write(make([]byte, 192))
_, errs[8] = fout.Write(make([]byte, 96))
_, errs[9] = fout.Write(make([]byte, 192))
for _, err := range errs {
if err != nil {
fin.Close()
fout.Close()
fmt.Println("Insufficient disk space!")
return 1
}
}
} else {
errs := make([]error, 9)
version := make([]byte, 15)
fin.Read(version)
_, errs[0] = rsDecode(rs5, version, !(*f))
tmp := make([]byte, 15)
fin.Read(tmp)
tmp, errs[1] = rsDecode(rs5, tmp, !(*f))
comments, _ := strconv.Atoi(string(tmp))
fin.Read(make([]byte, comments*3))
total -= int64(comments) * 3
flags := make([]byte, 15)
fin.Read(flags)
flags, errs[2] = rsDecode(rs5, flags, !(*f))
*p = flags[0] == 1
*r = flags[3] == 1
padded = flags[4] == 1
if flags[1] == 1 {
fin.Close()
fout.Close()
fmt.Println("Keyfiles are not supported!")
return 1
}
salt = make([]byte, 48)
fin.Read(salt)
salt, errs[3] = rsDecode(rs16, salt, !(*f))
hkdfSalt = make([]byte, 96)
fin.Read(hkdfSalt)
hkdfSalt, errs[4] = rsDecode(rs32, hkdfSalt, !(*f))
serpentIV = make([]byte, 48)
fin.Read(serpentIV)
serpentIV, errs[5] = rsDecode(rs16, serpentIV, !(*f))
nonce = make([]byte, 72)
fin.Read(nonce)
nonce, errs[6] = rsDecode(rs24, nonce, !(*f))
keyHashRef = make([]byte, 192)
fin.Read(keyHashRef)
keyHashRef, errs[7] = rsDecode(rs64, keyHashRef, !(*f))
fin.Read(make([]byte, 96))
authTag = make([]byte, 192)
fin.Read(authTag)
authTag, errs[8] = rsDecode(rs64, authTag, !(*f))
for _, err := range errs {
if err != nil {
fin.Close()
fout.Close()
fmt.Println("The volume header is irrecoverably damaged!")
return 1
}
}
}
if *p {
key = argon2.IDKey(password, salt, 8, 1<<20, 8, 32)
} else {
key = argon2.IDKey(password, salt, 4, 1<<20, 4, 32)
}
tmp := sha3.New512()
tmp.Write(key)
keyHash = tmp.Sum(nil)
if mode == "decrypt" {
if !bytes.Equal(keyHash, keyHashRef) {
fin.Close()
fout.Close()
fmt.Println("Incorrect password!")
return 1
}
}
done, counter := 0, 0
chacha, _ := chacha20.NewUnauthenticatedCipher(key, nonce)
subkey := make([]byte, 32)
hkdf := hkdf.New(sha3.New256, key, hkdfSalt, nil)
hkdf.Read(subkey)
if *p {
mac = hmac.New(sha3.New512, subkey)
} else {
mac, _ = blake2b.New512(subkey)
}
serpentKey := make([]byte, 32)
hkdf.Read(serpentKey)
s, _ := serpent.NewCipher(serpentKey)
serpent := cipher.NewCTR(s, serpentIV)
bar := progressbar.NewOptions(
int(total),
progressbar.OptionClearOnFinish(),
progressbar.OptionFullWidth(),
progressbar.OptionShowBytes(true),
progressbar.OptionUseIECUnits(true),
progressbar.OptionSetDescription(
(func() string {
if mode == "encrypt" {
return "Encrypting:"
}
return "Decrypting:"
})(),
),
)
for {
var src []byte
if mode == "decrypt" && *r {
src = make([]byte, MiB/128*136)
} else {
src = make([]byte, MiB)
}
size, err := fin.Read(src)
if err != nil {
break
}
src = src[:size]
dst := make([]byte, len(src))
bar.Write(src)
if mode == "encrypt" {
if *p {
serpent.XORKeyStream(dst, src)
copy(src, dst)
}
chacha.XORKeyStream(dst, src)
mac.Write(dst)
if *r {
copy(src, dst)
dst = nil
if len(src) == MiB {
for i := 0; i < MiB; i += 128 {
dst = append(dst, rsEncode(rs128, src[i:i+128])...)
}
} else {
chunks := math.Floor(float64(len(src)) / 128)
for i := 0; float64(i) < chunks; i++ {
dst = append(dst, rsEncode(rs128, src[i*128:(i+1)*128])...)
}
dst = append(dst, rsEncode(rs128, pad(src[int(chunks*128):]))...)
}
}
} else {
if *r {
copy(dst, src)
src = nil
if len(dst) == MiB/128*136 {
for i := 0; i < MiB/128*136; i += 136 {
tmp, err := rsDecode(rs128, dst[i:i+136], !(*f))
if err != nil {
fin.Close()
fout.Close()
fmt.Println("\nThe input file is irrecoverably damaged.")
return 1
}
if i == MiB/128*136-136 && done+MiB/128*136 >= int(total) && padded {
tmp = unpad(tmp)
}
src = append(src, tmp...)
}
} else {
chunks := len(dst)/136 - 1
for i := 0; i < chunks; i++ {
tmp, err := rsDecode(rs128, dst[i*136:(i+1)*136], !(*f))
if err != nil {
fin.Close()
fout.Close()
fmt.Println("\nThe input file is irrecoverably damaged.")
return 1
}
src = append(src, tmp...)
}
tmp, err := rsDecode(rs128, dst[int(chunks)*136:], !(*f))
if err != nil {
fin.Close()
fout.Close()
fmt.Println("\nThe input file is irrecoverably damaged.")
return 1
}
src = append(src, unpad(tmp)...)
}
dst = make([]byte, len(src))
}
mac.Write(src)
chacha.XORKeyStream(dst, src)
if *p {
copy(src, dst)
serpent.XORKeyStream(dst, src)
}
}
_, err = fout.Write(dst)
if err != nil {
if interrupted {
time.Sleep(1 * time.Second)
} else {
fin.Close()
fout.Close()
fmt.Println("\nInsufficient disk space!")
return 1
}
}
if mode == "decrypt" && *r {
done += MiB / 128 * 136
} else {
done += MiB
}
if counter >= 60*GiB {
nonce = make([]byte, 24)
hkdf.Read(nonce)
chacha, _ = chacha20.NewUnauthenticatedCipher(key, nonce)
serpentIV = make([]byte, 16)
hkdf.Read(serpentIV)
serpent = cipher.NewCTR(s, serpentIV)
counter = 0
}
}
if mode == "encrypt" {
fout.Seek(309, 0)
fout.Write(rsEncode(rs64, keyHash))
fout.Write(rsEncode(rs32, make([]byte, 32)))
fout.Write(rsEncode(rs64, mac.Sum(nil)))
} else {
if !bytes.Equal(mac.Sum(nil), authTag) {
fin.Close()
fout.Close()
if *k {
fmt.Println("\nThe modified output has been kept.")
return 0
} else {
fmt.Println("\nThe input volume is damaged or modified!")
if *r {
fmt.Println("Fortunately, this volume is encoded with Reed-Solomon.")
fmt.Println("Try again using the '-f' flag to repair the corruption.")
}
return 1
}
}
}
fin.Close()
fout.Close()
fmt.Println("Completed ->", fout.Name())
return 0
}
func main() {
if parse() == 1 {
os.Exit(1)
}
if auth() == 1 {
os.Exit(1)
}
if prepare() == 1 {
os.Exit(1)
}
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
go func() {
<-c
interrupted = true
if fin != nil {
fin.Close()
}
if fout != nil {
fmt.Print("\nSystem interrupt detected, cleaning up incomplete output: ")
fout.Close()
if err := os.Remove(fout.Name()); err == nil {
fmt.Print("Success.")
} else {
fmt.Print("Failure.")
}
}
if pzip != "" {
fmt.Print("\nSystem interrupt detected, cleaning up temporary files: ")
writer.Close()
file.Close()
if err := os.Remove(pzip); err == nil {
fmt.Print("Success.")
} else {
fmt.Print("Failure.")
}
}
fmt.Println()
os.Exit(1)
}()
if compress() == 1 {
os.Remove(pzip)
os.Exit(1)
} else {
defer os.Remove(pzip)
}
if work() == 1 {
if pzip != "" {
os.Remove(pzip)
}
if fout != nil {
os.Remove(fout.Name())
}
os.Exit(1)
}
}