1633 lines
38 KiB
Go
1633 lines
38 KiB
Go
package main
|
|
|
|
/*
|
|
|
|
Picocrypt v1.13
|
|
Copyright (c) Evan Su (https://evansu.cc)
|
|
Released under a GNU GPL v3 License
|
|
https://github.com/HACKERALERT/Picocrypt
|
|
|
|
~ In cryptography we trust ~
|
|
|
|
*/
|
|
|
|
import (
|
|
"io"
|
|
"os"
|
|
"fmt"
|
|
"math"
|
|
"time"
|
|
"sync"
|
|
"os/exec"
|
|
"strings"
|
|
"strconv"
|
|
"runtime"
|
|
"io/ioutil"
|
|
"image/color"
|
|
"crypto/md5"
|
|
"archive/zip"
|
|
"crypto/rand"
|
|
"crypto/sha1"
|
|
"encoding/hex"
|
|
"path/filepath"
|
|
"crypto/sha256"
|
|
"runtime/debug"
|
|
"github.com/pkg/browser"
|
|
"github.com/zeebo/blake3"
|
|
"golang.org/x/crypto/sha3"
|
|
"golang.org/x/crypto/argon2"
|
|
g "github.com/AllenDang/giu"
|
|
"golang.org/x/crypto/blake2b"
|
|
"golang.org/x/crypto/blake2s"
|
|
"github.com/atotto/clipboard"
|
|
di "github.com/OpenDiablo2/dialog"
|
|
"github.com/klauspost/reedsolomon"
|
|
ig "github.com/AllenDang/imgui-go"
|
|
"golang.org/x/crypto/chacha20poly1305"
|
|
"github.com/HACKERALERT/Picocypher/monocypher"
|
|
)
|
|
|
|
var version = "v1.13"
|
|
var exe,_ = os.Executable()
|
|
var rootDir = filepath.Dir(exe)
|
|
|
|
// Global variables
|
|
var dpi float32
|
|
var mode string
|
|
var working = false
|
|
var onlyFiles []string
|
|
var onlyFolders []string
|
|
var allFiles []string
|
|
var inputFile string
|
|
var outputFile string
|
|
|
|
// UI-related global variables
|
|
var tab = 0
|
|
var inputLabel = "Drag and drop file(s) and folder(s) into this window."
|
|
var outputEntry string
|
|
var outputWidth float32 = 376
|
|
var orLabel = "or"
|
|
var passwordState = g.InputTextFlags_Password
|
|
var showPassword = false
|
|
var keyfile = false
|
|
var keyfilePrompt = "Keyfile (optional):"
|
|
var progress float32 = 0
|
|
var progressInfo = ""
|
|
var status = "Ready."
|
|
var _status = "adfs"
|
|
var _status_color = color.RGBA{0xff,0xff,0xff,255}
|
|
var splitUnits = []string{
|
|
"KB",
|
|
"MB",
|
|
"GB",
|
|
}
|
|
var splitSelected int32
|
|
var items = []string{
|
|
"Normal (4 passes)",
|
|
"Paranoid (Still in development, don't use)",
|
|
}
|
|
var itemSelected int32
|
|
var shredProgress float32
|
|
var shredDone float32
|
|
var shredTotal float32
|
|
var shredOverlay string
|
|
var shredding = "Ready."
|
|
|
|
var recombine bool
|
|
|
|
|
|
// User input variables
|
|
var password string
|
|
var cPassword string
|
|
var keyfilePath string
|
|
var keyfileLabel = "Use a keyfile"
|
|
var metadata string
|
|
var keep bool
|
|
var erase bool
|
|
var reedsolo bool
|
|
var split bool
|
|
var splitSize string
|
|
var fast bool
|
|
var _fast bool
|
|
|
|
var kept = false
|
|
|
|
// Reed-Solomon encoders
|
|
var rs5_128,_ = reedsolomon.New(5,128)
|
|
var rs10_128,_ = reedsolomon.New(10,128)
|
|
var rs16_128,_ = reedsolomon.New(16,128)
|
|
var rs24_128,_ = reedsolomon.New(24,128)
|
|
var rs32_128,_ = reedsolomon.New(32,128)
|
|
var rs64_128,_ = reedsolomon.New(64,128)
|
|
|
|
// File checksum generator variables
|
|
var cs_md5 string
|
|
var cs_sha1 string
|
|
var cs_sha256 string
|
|
var cs_sha3_256 string
|
|
var cs_blake2b string
|
|
var cs_blake2s string
|
|
var cs_blake3 string
|
|
var cs_validate string
|
|
var md5_color = color.RGBA{0x10,0x10,0x10,255}
|
|
var sha1_color = color.RGBA{0x10,0x10,0x10,255}
|
|
var sha256_color = color.RGBA{0x10,0x10,0x10,255}
|
|
var sha3_256_color = color.RGBA{0x10,0x10,0x10,255}
|
|
var blake2b_color = color.RGBA{0x10,0x10,0x10,255}
|
|
var blake2s_color = color.RGBA{0x10,0x10,0x10,255}
|
|
var blake3_color = color.RGBA{0x10,0x10,0x10,255}
|
|
var cs_progress float32 = 0
|
|
var md5_selected = false
|
|
var sha1_selected = false
|
|
var sha256_selected = false
|
|
var sha3_256_selected = false
|
|
var blake2b_selected = false
|
|
var blake2s_selected = false
|
|
var blake3_selected = false
|
|
|
|
// Create the user interface
|
|
func startUI(){
|
|
g.SingleWindow("Picocrypt").Layout(
|
|
g.Style().SetColor(ig.StyleColorBorder,color.RGBA{0x10,0x10,0x10,255}).To(
|
|
// The tab bar, which contains different tabs for different features
|
|
g.TabBar("TabBar").Layout(
|
|
// File encryption/decryption tab
|
|
g.TabItem("Encryption/decryption").Layout(
|
|
// Update 'tab' to indicate active tab
|
|
g.Custom(func(){
|
|
if g.IsItemActive(){
|
|
tab = 0
|
|
}
|
|
}),
|
|
|
|
// Confirm overwrite with a modal
|
|
g.PopupModal("Confirmation").Layout(
|
|
g.Label("Output already exists. Overwrite?"),
|
|
g.Row(
|
|
g.Button("No").Size(110,0).OnClick(func(){
|
|
g.CloseCurrentPopup()
|
|
}),
|
|
g.Dummy(-118,0),
|
|
g.Button("Yes").Size(110,0).OnClick(func(){
|
|
g.CloseCurrentPopup()
|
|
go work()
|
|
}),
|
|
|
|
),
|
|
),
|
|
|
|
// Label listing the input files and a button to clear input files
|
|
//g.Dummy(0,10),
|
|
g.Row(
|
|
g.Label(inputLabel),
|
|
g.Dummy(-55,0),
|
|
g.Button("Clear").Size(46,0).OnClick(resetUI),
|
|
),
|
|
|
|
// Allow user to choose a custom output path and name
|
|
//g.Dummy(10,0),
|
|
g.Label("Save output as:"),
|
|
g.Row(
|
|
g.InputText("##output",&outputEntry).Size(outputWidth/dpi),
|
|
g.Label(orLabel),
|
|
g.Button("Save as").OnClick(func(){
|
|
file,_ := di.File().Title("Save as").Save()
|
|
|
|
// Return if user canceled the file dialog
|
|
if file==""{
|
|
return
|
|
}
|
|
|
|
// Remove the extra ".pcv" extension if needed
|
|
if strings.HasSuffix(file,".pcv"){
|
|
file = file[:len(file)-4]
|
|
}
|
|
outputEntry = file
|
|
}),
|
|
),
|
|
|
|
// Prompt for password
|
|
//g.Dummy(10,0),
|
|
g.Row(
|
|
g.Label("Password:"),
|
|
g.Dummy(-220,0),
|
|
g.Label(keyfilePrompt),
|
|
),
|
|
g.Row(
|
|
g.InputText("##password",&password).Size(200/dpi).Flags(passwordState),
|
|
g.Checkbox("##showPassword",&showPassword).OnChange(func(){
|
|
if passwordState==g.InputTextFlags_Password{
|
|
passwordState = g.InputTextFlags_None
|
|
}else{
|
|
passwordState = g.InputTextFlags_Password
|
|
}
|
|
g.Update()
|
|
}),
|
|
g.Dummy(-220,0),
|
|
g.Checkbox(keyfileLabel,&keyfile).OnChange(func(){
|
|
if !keyfile{
|
|
keyfileLabel = "Use a keyfile"
|
|
return
|
|
}
|
|
filename,err := di.File().Load()
|
|
if err!=nil{
|
|
keyfile = false
|
|
return
|
|
}
|
|
keyfileLabel = filename
|
|
keyfilePath = filename
|
|
}),
|
|
),
|
|
|
|
// Prompt to confirm password
|
|
//g.Dummy(10,0),
|
|
g.Label("Confirm password:"),
|
|
g.InputText("##cPassword",&cPassword).Size(200/dpi).Flags(passwordState),
|
|
|
|
// Optional metadata
|
|
//g.Dummy(10,0),
|
|
g.Label("Metadata (optional):"),
|
|
g.InputTextMultiline("##metadata",&metadata).Size(230,126),
|
|
|
|
// Advanced options can be enabled with checkboxes
|
|
//g.Dummy(10,0),
|
|
g.Checkbox("Keep decrypted output even if it's corrupted or modified",&keep),
|
|
g.Checkbox("Securely shred the original file(s) and folder(s)",&erase),
|
|
g.Row(
|
|
g.Checkbox("(Not finished yet) Encode with Reed-Solomon to prevent corruption",&reedsolo),
|
|
g.Button("?").OnClick(func(){
|
|
browser.OpenURL("https://en.wikipedia.org/wiki/Reed%E2%80%93Solomon_error_correction")
|
|
}),
|
|
),
|
|
g.Row(
|
|
g.Checkbox("Split output into chunks of",&split),
|
|
g.InputText("##splitSize",&splitSize).Size(30).Flags(g.InputTextFlags_CharsDecimal),
|
|
g.Combo("##splitter",splitUnits[splitSelected],splitUnits,&splitSelected).Size(40),
|
|
//g.Label("MB"),
|
|
),
|
|
g.Checkbox("Fast mode (less secure, not as durable)",&fast),
|
|
|
|
// Start and cancel buttons
|
|
//g.Dummy(10,0),
|
|
g.Button("Start").Size(-1,20).OnClick(func(){
|
|
if password!=cPassword{
|
|
_status = "Passwords don't match."
|
|
_status_color = color.RGBA{0xff,0x00,0x00,255}
|
|
return
|
|
}
|
|
if mode=="encrypt"{
|
|
outputFile = outputEntry+".pcv"
|
|
}else{
|
|
outputFile = outputEntry
|
|
}
|
|
_,err := os.Stat(outputFile)
|
|
if err==nil{
|
|
g.OpenPopup("Confirmation")
|
|
}else{
|
|
go work()
|
|
}
|
|
}),
|
|
|
|
//g.Dummy(10,0),
|
|
g.Style().SetColor(ig.StyleColorText,_status_color).To(
|
|
g.Label(_status),
|
|
),
|
|
),
|
|
|
|
// File shredder tab
|
|
g.TabItem("Shredder").Layout(
|
|
// Update 'tab' to indicate active tab
|
|
g.Custom(func(){
|
|
if g.IsItemActive(){
|
|
tab = 1
|
|
}
|
|
}),
|
|
|
|
g.Label("Select a mode below and drop file(s) and folder(s) here."),
|
|
g.Label("Warning: Anything dropped here will be shredded immediately!"),
|
|
//g.Dummy(10,0),
|
|
g.Combo("##shredder_mode",items[itemSelected],items,&itemSelected).Size(463),
|
|
//g.Dummy(10,0),
|
|
g.ProgressBar(shredProgress).Overlay(shredOverlay).Size(-1,0),
|
|
g.Label(shredding).Wrapped(true),
|
|
),
|
|
|
|
// File checksum generator tab
|
|
g.TabItem("Checksum").Layout(
|
|
// Update 'tab' to indicate active tab
|
|
g.Custom(func(){
|
|
if g.IsItemActive(){
|
|
tab = 2
|
|
}
|
|
}),
|
|
|
|
g.Label("Toggle the hashes you would like to generate and drop a file here."),
|
|
|
|
// MD5
|
|
//g.Dummy(10,0),
|
|
g.Row(
|
|
g.Checkbox("MD5:",&md5_selected),
|
|
g.Dummy(-45,0),
|
|
g.Button("Copy##md5").Size(36,0).OnClick(func(){
|
|
clipboard.WriteAll(cs_md5)
|
|
}),
|
|
),
|
|
g.Style().SetColor(ig.StyleColorBorder,md5_color).To(
|
|
g.InputText("##cs_md5",&cs_md5).Size(-1).Flags(g.InputTextFlags_ReadOnly),
|
|
),
|
|
|
|
// SHA1
|
|
//g.Dummy(10,0),
|
|
g.Row(
|
|
g.Checkbox("SHA1:",&sha1_selected),
|
|
g.Dummy(-45,0),
|
|
g.Button("Copy##sha1").Size(36,0).OnClick(func(){
|
|
clipboard.WriteAll(cs_sha1)
|
|
}),
|
|
),
|
|
g.Style().SetColor(ig.StyleColorBorder,sha1_color).To(
|
|
g.InputText("##cs_sha1",&cs_sha1).Size(-1).Flags(g.InputTextFlags_ReadOnly),
|
|
),
|
|
|
|
// SHA256
|
|
//g.Dummy(10,0),
|
|
g.Row(
|
|
g.Checkbox("SHA256:",&sha256_selected),
|
|
g.Dummy(-45,0),
|
|
g.Button("Copy##sha256").Size(36,0).OnClick(func(){
|
|
clipboard.WriteAll(cs_sha256)
|
|
}),
|
|
),
|
|
g.Style().SetColor(ig.StyleColorBorder,sha256_color).To(
|
|
g.InputText("##cs_sha256",&cs_sha256).Size(-1).Flags(g.InputTextFlags_ReadOnly),
|
|
),
|
|
|
|
// SHA3-256
|
|
//g.Dummy(10,0),
|
|
g.Row(
|
|
g.Checkbox("SHA3-256:",&sha3_256_selected),
|
|
g.Dummy(-45,0),
|
|
g.Button("Copy##sha3_256").Size(36,0).OnClick(func(){
|
|
clipboard.WriteAll(cs_sha3_256)
|
|
}),
|
|
),
|
|
g.Style().SetColor(ig.StyleColorBorder,sha3_256_color).To(
|
|
g.InputText("##cs_sha3_256",&cs_sha3_256).Size(-1).Flags(g.InputTextFlags_ReadOnly),
|
|
),
|
|
|
|
// BLAKE2b
|
|
//g.Dummy(10,0),
|
|
g.Row(
|
|
g.Checkbox("BLAKE2b:",&blake2b_selected),
|
|
g.Dummy(-45,0),
|
|
g.Button("Copy##blake2b").Size(36,0).OnClick(func(){
|
|
clipboard.WriteAll(cs_blake2b)
|
|
}),
|
|
),
|
|
g.Style().SetColor(ig.StyleColorBorder,blake2b_color).To(
|
|
g.InputText("##cs_blake2b",&cs_blake2b).Size(-1).Flags(g.InputTextFlags_ReadOnly),
|
|
),
|
|
|
|
// BLAKE2s
|
|
//g.Dummy(10,0),
|
|
g.Row(
|
|
g.Checkbox("BLAKE2s:",&blake2s_selected),
|
|
g.Dummy(-45,0),
|
|
g.Button("Copy##blake2s").Size(36,0).OnClick(func(){
|
|
clipboard.WriteAll(cs_blake2s)
|
|
}),
|
|
),
|
|
g.Style().SetColor(ig.StyleColorBorder,blake2s_color).To(
|
|
g.InputText("##cs_blake2s",&cs_blake2s).Size(-1).Flags(g.InputTextFlags_ReadOnly),
|
|
),
|
|
|
|
// BLAKE3
|
|
//g.Dummy(10,0),
|
|
g.Row(
|
|
g.Checkbox("BLAKE3:",&blake3_selected),
|
|
g.Dummy(-45,0),
|
|
g.Button("Copy##blake3").Size(36,0).OnClick(func(){
|
|
clipboard.WriteAll(cs_blake3)
|
|
}),
|
|
),
|
|
g.Style().SetColor(ig.StyleColorBorder,blake3_color).To(
|
|
g.InputText("##cs_blake3",&cs_blake3).Size(-1).Flags(g.InputTextFlags_ReadOnly),
|
|
),
|
|
|
|
// Input box for validating checksum
|
|
//g.Dummy(10,0),
|
|
g.Label("Validate a checksum:"),
|
|
g.InputText("##cs_validate",&cs_validate).Size(-1).OnChange(func(){
|
|
md5_color = color.RGBA{0x10,0x10,0x10,255}
|
|
sha1_color = color.RGBA{0x10,0x10,0x10,255}
|
|
sha256_color = color.RGBA{0x10,0x10,0x10,255}
|
|
sha3_256_color = color.RGBA{0x10,0x10,0x10,255}
|
|
blake2b_color = color.RGBA{0x10,0x10,0x10,255}
|
|
blake2s_color = color.RGBA{0x10,0x10,0x10,255}
|
|
blake3_color = color.RGBA{0x10,0x10,0x10,255}
|
|
if cs_validate==""{
|
|
return
|
|
}
|
|
if cs_validate==cs_md5{
|
|
md5_color = color.RGBA{0x00,0xff,0x00,255}
|
|
}else if cs_validate==cs_sha1{
|
|
sha1_color = color.RGBA{0x00,0xff,0x00,255}
|
|
}else if cs_validate==cs_sha256{
|
|
sha256_color = color.RGBA{0x00,0xff,0x00,255}
|
|
}else if cs_validate==cs_sha3_256{
|
|
sha3_256_color = color.RGBA{0x00,0xff,0x00,255}
|
|
}else if cs_validate==cs_blake2b{
|
|
blake2b_color = color.RGBA{0x00,0xff,0x00,255}
|
|
}else if cs_validate==cs_blake2s{
|
|
blake2s_color = color.RGBA{0x00,0xff,0x00,255}
|
|
}else if cs_validate==cs_blake3{
|
|
blake3_color = color.RGBA{0x00,0xff,0x00,255}
|
|
}
|
|
g.Update()
|
|
}),
|
|
|
|
// Progress bar
|
|
//g.Dummy(10,0),
|
|
g.Label("Progress:"),
|
|
g.ProgressBar(cs_progress).Size(-1,0),
|
|
),
|
|
g.TabItem("About").Layout(
|
|
// Update 'tab' to indicate active tab
|
|
g.Custom(func(){
|
|
if g.IsItemActive(){
|
|
tab = 3
|
|
}
|
|
}),
|
|
//g.Dummy(30,0),
|
|
g.Label("Picocrypt "+version+", created by Evan Su (https://evansu.cc)"),
|
|
),
|
|
),
|
|
),
|
|
)
|
|
if working{
|
|
g.SingleWindow("Working..").IsOpen(&working).Layout(
|
|
//g.Dummy(30,0),
|
|
g.Label("Tips:"),
|
|
g.Label(" - Choose a strong password with more than 16 characters."),
|
|
g.Label(" - Use a unique password that isn't used anywhere else."),
|
|
g.Label(" - Trust no one but yourself and never give out your key."),
|
|
g.Label(" - For highly sensitive files, encrypt them while offline."),
|
|
g.Label(" - An antivirus can be beneficial to prevent keyloggers."),
|
|
g.Label(" - Encrypt your root filesystem for maximal security."),
|
|
g.Dummy(0,-50),
|
|
|
|
|
|
// Progress bar
|
|
g.Row(
|
|
g.ProgressBar(progress).Size(-54,0).Overlay(progressInfo),
|
|
g.Dummy(-59,0),
|
|
g.Button("Cancel").Size(50,0).OnClick(func(){
|
|
working = false
|
|
}),
|
|
),
|
|
//g.Dummy(10,0),
|
|
g.Label(status),
|
|
)
|
|
}
|
|
}
|
|
|
|
// Handle files dropped into Picocrypt by user
|
|
func onDrop(names []string){
|
|
_status = ""
|
|
recombine = false
|
|
if tab==0{
|
|
// Clear variables
|
|
onlyFiles = nil
|
|
onlyFolders = nil
|
|
allFiles = nil
|
|
files,folders := 0,0
|
|
|
|
// Reset UI
|
|
resetUI()
|
|
|
|
// Hide the ".pcv" label
|
|
orLabel = "or"
|
|
outputWidth = 376
|
|
|
|
// There's only one dropped item
|
|
if len(names)==1{
|
|
stat,_ := os.Stat(names[0])
|
|
|
|
// Check if dropped item is a file or a folder
|
|
if stat.IsDir(){
|
|
folders++
|
|
inputLabel = "1 folder selected."
|
|
|
|
// Add the folder
|
|
onlyFolders = append(onlyFolders,names[0])
|
|
|
|
// Set 'outputEntry' to 'Encrypted.zip' in the same directory
|
|
outputEntry = filepath.Join(filepath.Dir(names[0]),"Encrypted.zip")
|
|
|
|
mode = "encrypt"
|
|
// Show the ".pcv" file extension
|
|
orLabel = ".pcv or"
|
|
outputWidth = 341
|
|
}else{
|
|
files++
|
|
name := filepath.Base(names[0])
|
|
|
|
nums := []string{"0","1","2","3","4","5","6","7","8","9"}
|
|
endsNum := false
|
|
for _,i := range(nums){
|
|
if strings.HasSuffix(names[0],i){
|
|
endsNum = true
|
|
}
|
|
}
|
|
isSplit := strings.Contains(names[0],".pcv.")&&endsNum
|
|
|
|
// Decide if encrypting or decrypting
|
|
if strings.HasSuffix(names[0],".pcv")||isSplit{
|
|
mode = "decrypt"
|
|
inputLabel = name+" (will decrypt)"
|
|
|
|
if isSplit{
|
|
ind := strings.Index(names[0],".pcv")
|
|
names[0] = names[0][:ind]
|
|
outputEntry = names[0]
|
|
recombine = true
|
|
}else{
|
|
outputEntry = names[0][:len(names[0])-4]
|
|
}
|
|
|
|
|
|
// Open input file in read-only mode
|
|
fin,_ := os.Open(names[0])
|
|
|
|
// Read metadata and insert into box
|
|
fin.Read(make([]byte,133))
|
|
tmp := make([]byte,138)
|
|
fin.Read(tmp)
|
|
tmp = rsDecode(tmp,rs10_128,10)
|
|
metadataLength,_ := strconv.Atoi(string(tmp))
|
|
//fmt.Println(metadataLength)
|
|
tmp = make([]byte,metadataLength)
|
|
fin.Read(tmp)
|
|
metadata = string(tmp)
|
|
|
|
flags := make([]byte,133)
|
|
fin.Read(flags)
|
|
flags = rsDecode(flags,rs5_128,5)
|
|
|
|
if flags[1]==1{
|
|
keyfilePrompt = "Keyfile (required):"
|
|
keyfileLabel = "Click here to select keyfile."
|
|
}
|
|
|
|
fin.Close()
|
|
}else{
|
|
mode = "encrypt"
|
|
inputLabel = name+" (will encrypt)"
|
|
outputEntry = names[0]
|
|
|
|
// Show the ".pcv" file extension
|
|
orLabel = ".pcv or"
|
|
outputWidth = 341
|
|
}
|
|
|
|
// Add the file
|
|
onlyFiles = append(onlyFiles,names[0])
|
|
|
|
inputFile = names[0]
|
|
}
|
|
}else{
|
|
mode = "encrypt"
|
|
// Show the ".pcv" file extension
|
|
orLabel = ".pcv or"
|
|
outputWidth = 341
|
|
|
|
// There are multiple dropped items, check each one
|
|
for _,name := range names{
|
|
stat,_ := os.Stat(name)
|
|
|
|
// Check if item is a file or a directory
|
|
if stat.IsDir(){
|
|
folders++
|
|
onlyFolders = append(onlyFolders,name)
|
|
}else{
|
|
files++
|
|
onlyFiles = append(onlyFiles,name)
|
|
allFiles = append(allFiles,name)
|
|
}
|
|
}
|
|
|
|
if folders==0{
|
|
// If folders==0, then there are multiple files
|
|
inputLabel = fmt.Sprintf("%d files selected.",files)
|
|
}else if files==0{
|
|
// If files==0, then there are multiple folders
|
|
inputLabel = fmt.Sprintf("%d folders selected.",folders)
|
|
}else{
|
|
// There are multiple files and folders
|
|
if files==1&&folders>1{
|
|
inputLabel = fmt.Sprintf("1 file and %d folders selected.",folders)
|
|
}else if folders==1&&files>1{
|
|
inputLabel = fmt.Sprintf("%d files and 1 folder selected.",files)
|
|
}else if folders==1&&files==1{
|
|
inputLabel = "1 file and 1 folder selected."
|
|
}else{
|
|
inputLabel = fmt.Sprintf("%d files and %d folders selected.",files,folders)
|
|
}
|
|
}
|
|
|
|
// Set 'outputEntry' to 'Encrypted.zip' in the same directory
|
|
outputEntry = filepath.Join(filepath.Dir(names[0]),"Encrypted.zip")
|
|
}
|
|
|
|
// If there are folders that were dropped, recusively add all files into 'allFiles'
|
|
if folders>0{
|
|
for _,name := range(onlyFolders){
|
|
filepath.Walk(name,func(path string,_ os.FileInfo,_ error) error{
|
|
stat,_ := os.Stat(path)
|
|
if !stat.IsDir(){
|
|
allFiles = append(allFiles,path)
|
|
}
|
|
return nil
|
|
})
|
|
}
|
|
}
|
|
}else if tab==1{
|
|
go shred(names,true)
|
|
}else if tab==2{
|
|
go generateChecksums(names[0])
|
|
}
|
|
|
|
// Update the UI
|
|
g.Update()
|
|
}
|
|
|
|
// Start encryption/decryption
|
|
func work(){
|
|
debug.FreeOSMemory()
|
|
// Set some variables
|
|
working = true
|
|
//headerBroken := false
|
|
//reedsoloFixed := 0
|
|
//reedsoloErrors := 0
|
|
var salt []byte
|
|
var nonce []byte
|
|
var keyHash []byte
|
|
var _keyHash []byte
|
|
var khash []byte
|
|
var khash_hash []byte
|
|
var _khash_hash []byte
|
|
var nonces []byte
|
|
_fast = fast
|
|
|
|
// Set the output file based on mode
|
|
if mode=="encrypt"{
|
|
// Compress files into a zip archive
|
|
if len(allFiles)>1||len(onlyFolders)>0{
|
|
rootDir := filepath.Dir(outputEntry)
|
|
inputFile = outputEntry
|
|
fmt.Println(inputFile)
|
|
file,_ := os.Create(inputFile)
|
|
|
|
w := zip.NewWriter(file)
|
|
for _,path := range(allFiles){
|
|
if path==inputFile{
|
|
continue
|
|
}
|
|
stat,_ := os.Stat(path)
|
|
header,_ := zip.FileInfoHeader(stat)
|
|
header.Name = strings.Replace(path,rootDir,"",1)
|
|
header.Method = zip.Deflate
|
|
writer,_ := w.CreateHeader(header)
|
|
file,_ := os.Open(path)
|
|
io.Copy(writer,file)
|
|
file.Close()
|
|
}
|
|
w.Flush()
|
|
w.Close()
|
|
file.Close()
|
|
}
|
|
}
|
|
|
|
if recombine{
|
|
status = "Recombining file..."
|
|
total := 0
|
|
|
|
for{
|
|
_,err := os.Stat(fmt.Sprintf("%s.%d",inputFile+".pcv",total))
|
|
if err!=nil{
|
|
break
|
|
}
|
|
total++
|
|
}
|
|
fout,_ := os.OpenFile(
|
|
outputEntry+".pcv",
|
|
os.O_RDWR|os.O_CREATE|os.O_TRUNC,
|
|
0755,
|
|
)
|
|
for i:=0;i<total;i++{
|
|
fin,_ := os.Open(fmt.Sprintf("%s.%d",inputFile+".pcv",i))
|
|
for{
|
|
data := make([]byte,1048576)
|
|
read,err := fin.Read(data)
|
|
if err!=nil{
|
|
break
|
|
}
|
|
data = data[:read]
|
|
fout.Write(data)
|
|
}
|
|
fin.Close()
|
|
progressInfo = fmt.Sprintf("%d/%d",i,total)
|
|
progress = float32(i)/float32(total)
|
|
g.Update()
|
|
}
|
|
fout.Close()
|
|
outputFile = outputEntry
|
|
inputFile = outputEntry+".pcv"
|
|
progressInfo = ""
|
|
}
|
|
|
|
fmt.Println(inputFile)
|
|
stat,_ := os.Stat(inputFile)
|
|
total := stat.Size()
|
|
fmt.Println(total)
|
|
|
|
// Open input file in read-only mode
|
|
fin,_ := os.Open(inputFile)
|
|
|
|
var fout *os.File
|
|
|
|
fmt.Println(mode)
|
|
|
|
// If encrypting, generate values; If decrypting, read values from file
|
|
if mode=="encrypt"{
|
|
status = "Generating values..."
|
|
g.Update()
|
|
fout,_ = os.OpenFile(
|
|
outputFile,
|
|
os.O_RDWR|os.O_CREATE|os.O_TRUNC,
|
|
0755,
|
|
)
|
|
|
|
// Argon2 salt and XChaCha20 nonce
|
|
salt = make([]byte,16)
|
|
nonce = make([]byte,24)
|
|
|
|
// Write version to file
|
|
fout.Write(rsEncode([]byte(version),rs5_128,133))
|
|
|
|
// Encode the length of the metadata with Reed-Solomon
|
|
metadataLength := []byte(fmt.Sprintf("%010d",len(metadata)))
|
|
//fmt.Println("metadataLength:",metadataLength)
|
|
metadataLength = rsEncode(metadataLength,rs10_128,138)
|
|
|
|
// Write the length of the metadata to file
|
|
fout.Write(metadataLength)
|
|
|
|
// Write the actual metadata
|
|
fout.Write([]byte(metadata))
|
|
|
|
flags := make([]byte,5)
|
|
if fast{
|
|
flags[0] = 1
|
|
}
|
|
if keyfile{
|
|
flags[1] = 1
|
|
}
|
|
//fmt.Println("flags:",flags)
|
|
flags = rsEncode(flags,rs5_128,133)
|
|
fout.Write(flags)
|
|
|
|
// Fill salt and nonce with Go's CSPRNG
|
|
rand.Read(salt)
|
|
rand.Read(nonce)
|
|
|
|
fmt.Println("salt: ",salt)
|
|
fmt.Println("nonce: ",nonce)
|
|
|
|
// Encode salt with Reed-Solomon and write to file
|
|
_salt := rsEncode(salt,rs16_128,144)
|
|
fout.Write(_salt)
|
|
|
|
// Encode nonce with Reed-Solomon and write to file
|
|
tmp := rsEncode(nonce,rs24_128,152)
|
|
fout.Write(tmp)
|
|
|
|
// Write placeholder for hash of key
|
|
fout.Write(make([]byte,192))
|
|
|
|
// Write placeholder for hash of hash of keyfile
|
|
fout.Write(make([]byte,160))
|
|
|
|
|
|
pairs := int(math.Ceil(float64(total)/1048576))
|
|
|
|
offset := 152*pairs+144
|
|
|
|
// Write placeholder for nonce/Poly1305 pairs
|
|
fout.Write(make([]byte,offset))
|
|
}else{
|
|
status = "Reading values..."
|
|
g.Update()
|
|
version := make([]byte,133)
|
|
fin.Read(version)
|
|
version = rsDecode(version,rs5_128,5)
|
|
|
|
tmp := make([]byte,138)
|
|
fin.Read(tmp)
|
|
tmp = rsDecode(tmp,rs10_128,10)
|
|
metadataLength,_ := strconv.Atoi(string(tmp))
|
|
//fmt.Println("metadataLength",metadataLength)
|
|
|
|
fin.Read(make([]byte,metadataLength))
|
|
|
|
flags := make([]byte,133)
|
|
fin.Read(flags)
|
|
flags = rsDecode(flags,rs5_128,5)
|
|
//fmt.Println("flags",flags)
|
|
fast = flags[0]==1
|
|
keyfile = flags[1]==1
|
|
|
|
salt = make([]byte,144)
|
|
fin.Read(salt)
|
|
salt = rsDecode(salt,rs16_128,16)
|
|
|
|
nonce = make([]byte,152)
|
|
fin.Read(nonce)
|
|
nonce = rsDecode(nonce,rs24_128,24)
|
|
|
|
fmt.Println("salt: ",salt)
|
|
fmt.Println("nonce: ",nonce)
|
|
|
|
_keyHash = make([]byte,192)
|
|
fin.Read(_keyHash)
|
|
_keyHash = rsDecode(_keyHash,rs64_128,64)
|
|
//fmt.Println("keyHash",keyHash)
|
|
|
|
_khash_hash = make([]byte,160)
|
|
fin.Read(_khash_hash)
|
|
_khash_hash = rsDecode(_khash_hash,rs32_128,32)
|
|
//fmt.Println("crcHash",crcHash)
|
|
|
|
_tmp := math.Ceil(float64(total-int64(metadataLength+1196))/float64(1048728))
|
|
nonces = make([]byte,int(_tmp*152)+144)
|
|
fin.Read(nonces)
|
|
//fmt.Println("Nonces: ",nonces)
|
|
}
|
|
|
|
g.Update()
|
|
status = "Deriving key..."
|
|
progress = 0
|
|
|
|
// Derive encryption/decryption key
|
|
var key []byte
|
|
if fast{
|
|
key = argon2.IDKey(
|
|
[]byte(password),
|
|
salt,
|
|
4,
|
|
131072,
|
|
4,
|
|
32,
|
|
)[:]
|
|
}else{
|
|
key = argon2.IDKey(
|
|
[]byte(password),
|
|
salt,
|
|
8,
|
|
1048576,
|
|
8,
|
|
32,
|
|
)[:]
|
|
}
|
|
|
|
fmt.Println("key",key)
|
|
if !working{
|
|
_status = "Operation cancelled by user."
|
|
_status_color = color.RGBA{0xff,0xff,0xff,255}
|
|
fast = _fast
|
|
debug.FreeOSMemory()
|
|
return
|
|
}
|
|
|
|
if keyfile{
|
|
kin,_ := os.Open(keyfilePath)
|
|
kstat,_ := os.Stat(keyfilePath)
|
|
fmt.Println(kstat.Size())
|
|
kbytes := make([]byte,kstat.Size())
|
|
kin.Read(kbytes)
|
|
kin.Close()
|
|
ksha3 := sha3.New256()
|
|
ksha3.Write(kbytes)
|
|
khash = ksha3.Sum(nil)
|
|
|
|
khash_sha3 := sha3.New256()
|
|
khash_sha3.Write(khash)
|
|
khash_hash = khash_sha3.Sum(nil)
|
|
fmt.Println("khash",khash)
|
|
fmt.Println("khash_hash",khash_hash)
|
|
}
|
|
|
|
//key = make([]byte,32)
|
|
fmt.Println("output",outputFile)
|
|
sha3_512 := sha3.New512()
|
|
sha3_512.Write(key)
|
|
keyHash = sha3_512.Sum(nil)
|
|
//fmt.Println("keyHash: ",keyHash)
|
|
|
|
// Check is password is correct
|
|
if mode=="decrypt"{
|
|
keyCorrect := true
|
|
keyfileCorrect := true
|
|
var tmp bool
|
|
for i,j := range(_keyHash){
|
|
if keyHash[i]!=j{
|
|
keyCorrect = false
|
|
break
|
|
}
|
|
}
|
|
if keyfile{
|
|
for i,j := range(_khash_hash){
|
|
if khash_hash[i]!=j{
|
|
keyfileCorrect = false
|
|
break
|
|
}
|
|
}
|
|
tmp = !keyCorrect||!keyfileCorrect
|
|
}else{
|
|
tmp = !keyCorrect
|
|
}
|
|
if tmp{
|
|
if keep{
|
|
kept = true
|
|
}else{
|
|
fin.Close()
|
|
working = false
|
|
if !keyCorrect{
|
|
_status = "The provided password is incorrect."
|
|
}else{
|
|
_status = "The provided keyfile is incorrect."
|
|
}
|
|
_status_color = color.RGBA{0xff,0x00,0x00,255}
|
|
key = nil
|
|
fast = _fast
|
|
if recombine{
|
|
os.Remove(inputFile)
|
|
}
|
|
debug.FreeOSMemory()
|
|
return
|
|
}
|
|
}
|
|
|
|
fout,_ = os.OpenFile(
|
|
outputFile,
|
|
os.O_RDWR|os.O_CREATE|os.O_TRUNC,
|
|
0755,
|
|
)
|
|
}
|
|
|
|
if keyfile{
|
|
// XOR key and keyfile
|
|
tmp := key
|
|
key = make([]byte,32)
|
|
for i,_ := range(key){
|
|
key[i] = tmp[i]^khash[i]
|
|
}
|
|
fmt.Println("key",key)
|
|
}
|
|
|
|
|
|
done := 0
|
|
counter := 0
|
|
startTime := time.Now()
|
|
|
|
cipher,_ := chacha20poly1305.NewX(key)
|
|
|
|
if mode=="decrypt"{
|
|
_mac := nonces[len(nonces)-144:]
|
|
_mac = rsDecode(_mac,rs16_128,16)
|
|
//fmt.Println("_mac ",_mac)
|
|
nonces = nonces[:len(nonces)-144]
|
|
var tmp []byte
|
|
var chunk []byte
|
|
for i,j := range(nonces){
|
|
chunk = append(chunk,j)
|
|
if (i+1)%152==0{
|
|
chunk = rsDecode(chunk,rs24_128,24)
|
|
for _,k := range(chunk){
|
|
tmp = append(tmp,k)
|
|
}
|
|
chunk = nil
|
|
}
|
|
}
|
|
/*for _,j := range(_mac){
|
|
tmp = append(tmp,j)
|
|
}*/
|
|
|
|
var authentic bool
|
|
nonces,authentic = monocypher.Unlock(tmp,nonce,key,_mac)
|
|
if !authentic{
|
|
if keep{
|
|
kept = true
|
|
}else{
|
|
fin.Close()
|
|
fout.Close()
|
|
working = false
|
|
_status = "The file is either corrupted or intentionally modified."
|
|
_status_color = color.RGBA{0xff,0x00,0x00,255}
|
|
fast = _fast
|
|
debug.FreeOSMemory()
|
|
return
|
|
}
|
|
}
|
|
//fmt.Println("UNENCRYPTED NONCES: ",nonces)
|
|
}
|
|
for{
|
|
if !working{
|
|
fin.Close()
|
|
fout.Close()
|
|
os.Remove(outputFile)
|
|
_status = "Operation cancelled by user."
|
|
_status_color = color.RGBA{0xff,0xff,0xff,255}
|
|
fast = _fast
|
|
debug.FreeOSMemory()
|
|
return
|
|
}
|
|
//fmt.Println("Encrypt/decrypt loop")
|
|
var _data []byte
|
|
var data []byte
|
|
var _nonce []byte
|
|
if mode=="encrypt"{
|
|
_data = make([]byte,1048576)
|
|
}else{
|
|
_data = make([]byte,1048592)
|
|
}
|
|
|
|
size,err := fin.Read(_data)
|
|
if err!=nil{
|
|
break
|
|
}
|
|
data = _data[:size]
|
|
|
|
|
|
if mode=="encrypt"{
|
|
_nonce = make([]byte,24)
|
|
rand.Read(_nonce)
|
|
for _,i := range(_nonce){
|
|
nonces = append(nonces,i)
|
|
}
|
|
}else{
|
|
_nonce = nonces[counter*24:counter*24+24]
|
|
}
|
|
|
|
//fmt.Println("Data nonce: ",_nonce)
|
|
//fmt.Println("Data: ",data)
|
|
if mode=="encrypt"{
|
|
if fast{
|
|
data = cipher.Seal(nil,_nonce,data,nil)
|
|
fout.Write(data)
|
|
//crc.Write(data)
|
|
}else{
|
|
mac,data := monocypher.Lock(data,_nonce,key)
|
|
fout.Write(data)
|
|
fout.Write(mac)
|
|
//crc.Write(data)
|
|
//crc.Write(mac)
|
|
}
|
|
|
|
//fout.Write(data)
|
|
}else{
|
|
//fmt.Println("DECODE LOOP")
|
|
//crc.Write(data)
|
|
if fast{
|
|
data,err = cipher.Open(nil,_nonce,data,nil)
|
|
if err!=nil{
|
|
if keep{
|
|
kept = true
|
|
mac := data[len(data)-16:]
|
|
data = data[:len(data)-16]
|
|
data,_ = monocypher.Unlock(data,_nonce,key,mac)
|
|
}else{
|
|
fin.Close()
|
|
fout.Close()
|
|
broken()
|
|
fast = _fast
|
|
debug.FreeOSMemory()
|
|
return
|
|
}
|
|
}
|
|
}else{
|
|
//crc.Write(data)
|
|
mac := data[len(data)-16:]
|
|
data = data[:len(data)-16]
|
|
var authentic bool
|
|
data,authentic = monocypher.Unlock(data,_nonce,key,mac)
|
|
if !authentic{
|
|
if keep{
|
|
kept = true
|
|
}else{
|
|
fin.Close()
|
|
fout.Close()
|
|
broken()
|
|
fast = _fast
|
|
debug.FreeOSMemory()
|
|
return
|
|
}
|
|
}
|
|
}
|
|
fout.Write(data)
|
|
//fmt.Println(authentic)
|
|
//fmt.Println("DECRYPTED DATA: ",data)
|
|
}
|
|
|
|
done += 1048576
|
|
counter++
|
|
|
|
progress = float32(done)/float32(total)
|
|
|
|
elapsed:= float64(int64(time.Now().Sub(startTime)))/float64(1000000000)
|
|
|
|
speed := (float64(done)/elapsed)/1000000
|
|
eta := math.Abs(float64(total-int64(done))/(speed*1000000))
|
|
|
|
progressInfo = fmt.Sprintf("%.2f%%",progress*100)
|
|
|
|
status = fmt.Sprintf("Working at %.2f MB/s (ETA: %.1fs)",speed,eta)
|
|
|
|
g.Update()
|
|
}
|
|
|
|
if mode=="encrypt"{
|
|
//fmt.Println("'nonces' before RS: ",nonces)
|
|
fout.Seek(int64(700+len(metadata)),0)
|
|
fout.Write(rsEncode(keyHash,rs64_128,192))
|
|
fout.Write(rsEncode(khash_hash,rs32_128,160))
|
|
|
|
_mac,tmp := monocypher.Lock(nonces,nonce,key)
|
|
fmt.Println(_mac)
|
|
//tmp := cipher.Seal(nil,nonce,nonces,nil)
|
|
//fmt.Println("ENCRYPTED NONCES: ",tmp)
|
|
//_mac := tmp[len(tmp)-16:]
|
|
|
|
//tmp = tmp[:len(tmp)-16]
|
|
var chunk []byte
|
|
|
|
for i,j := range(tmp){
|
|
chunk = append(chunk,j)
|
|
if (i+1)%24==0{
|
|
fout.Write(rsEncode(chunk,rs24_128,152))
|
|
//fmt.Println(rsEncode(chunk,rs24_128,152))
|
|
chunk = nil
|
|
}
|
|
}
|
|
fout.Write(rsEncode(_mac,rs16_128,144))
|
|
|
|
}else{
|
|
//fmt.Println("crcHash: ",crcHash)
|
|
//fmt.Println("crc.Sum: ",crc.Sum(nil))
|
|
}
|
|
|
|
fin.Close()
|
|
fout.Close()
|
|
|
|
if split{
|
|
status = "Splitting file..."
|
|
stat,_ := os.Stat(outputFile)
|
|
size := stat.Size()
|
|
finished := 0
|
|
var splitted []string
|
|
fmt.Println(size)
|
|
chunkSize,_ := strconv.Atoi(splitSize)
|
|
fmt.Println(splitSelected)
|
|
if splitSelected==0{
|
|
chunkSize *= 1024
|
|
}else if splitSelected==1{
|
|
chunkSize *= 1048576
|
|
}else{
|
|
chunkSize *= 1073741824
|
|
}
|
|
chunks := int(math.Ceil(float64(size)/float64(chunkSize)))
|
|
fin,_ := os.Open(outputFile)
|
|
for i:=0;i<chunks;i++{
|
|
fmt.Println(fmt.Sprintf("%s.%d",outputFile,i))
|
|
fout,_ := os.OpenFile(
|
|
fmt.Sprintf("%s.%d",outputFile,i),
|
|
os.O_RDWR|os.O_CREATE|os.O_TRUNC,
|
|
0755,
|
|
)
|
|
done := 0
|
|
for{
|
|
data := make([]byte,1048576)
|
|
read,err := fin.Read(data)
|
|
if err!=nil{
|
|
break
|
|
}
|
|
if !working{
|
|
fin.Close()
|
|
fout.Close()
|
|
_status = "Operation cancelled by user."
|
|
_status_color = color.RGBA{0xff,0xff,0xff,255}
|
|
for _,j := range(splitted){
|
|
os.Remove(j)
|
|
}
|
|
os.Remove(fmt.Sprintf("%s.%d",outputFile,i))
|
|
fmt.Println("outputFile",outputFile)
|
|
os.Remove(outputFile)
|
|
fast = _fast
|
|
debug.FreeOSMemory()
|
|
return
|
|
}
|
|
data = data[:read]
|
|
fout.Write(data)
|
|
done += read
|
|
if done>=chunkSize{
|
|
break
|
|
}
|
|
}
|
|
fout.Close()
|
|
finished++
|
|
splitted = append(splitted,fmt.Sprintf("%s.%d",outputFile,i))
|
|
progress = float32(finished)/float32(chunks)
|
|
progressInfo = fmt.Sprintf("%d/%d",finished,chunks)
|
|
g.Update()
|
|
}
|
|
fin.Close()
|
|
if erase{
|
|
status = "Shredding the unsplitted file..."
|
|
progressInfo = ""
|
|
shred([]string{outputFile}[:],false)
|
|
}else{
|
|
os.Remove(outputFile)
|
|
}
|
|
}
|
|
|
|
if recombine{
|
|
os.Remove(inputFile)
|
|
}
|
|
|
|
// Delete the temporary zip file
|
|
if len(allFiles)>1{
|
|
if erase{
|
|
progressInfo = ""
|
|
status = "Shredding temporary files..."
|
|
shred([]string{outputEntry}[:],false)
|
|
}else{
|
|
os.Remove(outputEntry)
|
|
}
|
|
}
|
|
fmt.Println("==============================")
|
|
if erase{
|
|
progressInfo = ""
|
|
shred(onlyFiles,false)
|
|
shred(onlyFolders,false)
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
resetUI()
|
|
if kept{
|
|
_status = "The input is corrupted and/or modified. Please be careful."
|
|
_status_color = color.RGBA{0xff,0xff,0x00,255}
|
|
}else{
|
|
_status = "Completed."
|
|
_status_color = color.RGBA{0x00,0xff,0x00,255}
|
|
}
|
|
working = false
|
|
kept = false
|
|
key = nil
|
|
status = "Ready."
|
|
debug.FreeOSMemory()
|
|
fmt.Println("Exit goroutine")
|
|
}
|
|
|
|
func shred(names []string,separate bool){
|
|
shredTotal = 0
|
|
shredDone = 0
|
|
if separate{
|
|
shredOverlay = "Shredding..."
|
|
}
|
|
for _,name := range(names){
|
|
filepath.Walk(name,func(path string,_ os.FileInfo,err error) error{
|
|
if err!=nil{
|
|
return nil
|
|
}
|
|
stat,_ := os.Stat(path)
|
|
if !stat.IsDir(){
|
|
shredTotal++
|
|
}
|
|
return nil
|
|
})
|
|
}
|
|
for _,name := range(names){
|
|
shredding = name
|
|
if runtime.GOOS=="linux"||runtime.GOOS=="darwin"{
|
|
stat,_ := os.Stat(name)
|
|
if stat.IsDir(){
|
|
var coming []string
|
|
filepath.Walk(name,func(path string,_ os.FileInfo,err error) error{
|
|
if err!=nil{
|
|
return nil
|
|
}
|
|
fmt.Println(path)
|
|
stat,_ := os.Stat(path)
|
|
if !stat.IsDir(){
|
|
if len(coming)==128{
|
|
var wg sync.WaitGroup
|
|
for i,j := range(coming){
|
|
wg.Add(1)
|
|
go func(wg *sync.WaitGroup,id int,j string){
|
|
defer wg.Done()
|
|
cmd := exec.Command("")
|
|
if runtime.GOOS=="linux"{
|
|
cmd = exec.Command("shred","-ufvz","-n","3",j)
|
|
}else{
|
|
cmd = exec.Command("rm","-rfP",j)
|
|
}
|
|
output,err := cmd.Output()
|
|
fmt.Println(err)
|
|
fmt.Println(output)
|
|
shredding = j
|
|
shredDone++
|
|
shredUpdate(separate)
|
|
g.Update()
|
|
}(&wg,i,j)
|
|
|
|
}
|
|
wg.Wait()
|
|
coming = nil
|
|
}else{
|
|
coming = append(coming,path)
|
|
}
|
|
}
|
|
return nil
|
|
})
|
|
fmt.Println(coming)
|
|
for _,i := range(coming){
|
|
go func(){
|
|
cmd := exec.Command("")
|
|
if runtime.GOOS=="linux"{
|
|
cmd = exec.Command("shred","-ufvz","-n","3",i)
|
|
}else{
|
|
cmd = exec.Command("rm","-rfP",i)
|
|
}
|
|
output,err := cmd.Output()
|
|
fmt.Println(err)
|
|
fmt.Println(output)
|
|
shredding = i
|
|
shredDone++
|
|
shredUpdate(separate)
|
|
g.Update()
|
|
}()
|
|
}
|
|
os.RemoveAll(name)
|
|
}else{
|
|
cmd := exec.Command("")
|
|
if runtime.GOOS=="linux"{
|
|
cmd = exec.Command("shred","-ufvz","-n","3",name)
|
|
}else{
|
|
cmd = exec.Command("rm","-rfP",name)
|
|
}
|
|
cmd.Run()
|
|
shredding = name+"/*"
|
|
shredDone++
|
|
shredUpdate(separate)
|
|
}
|
|
}else if runtime.GOOS=="windows"{
|
|
stat,_ := os.Stat(name)
|
|
if stat.IsDir(){
|
|
filepath.Walk(name,func(path string,_ os.FileInfo,err error) error{
|
|
if err!=nil{
|
|
return nil
|
|
}
|
|
fmt.Println(path)
|
|
stat,_ := os.Stat(path)
|
|
if stat.IsDir(){
|
|
t := 0
|
|
files,_ := ioutil.ReadDir(path)
|
|
for _,f := range(files){
|
|
if !f.IsDir(){
|
|
t++
|
|
}
|
|
}
|
|
shredDone += float32(t)
|
|
shredUpdate(separate)
|
|
tmp := filepath.Join(rootDir,"sdelete64.exe")
|
|
cmd := exec.Command(tmp,"*","-p","4")
|
|
cmd.Dir = path
|
|
cmd.Run()
|
|
shredding = strings.ReplaceAll(path,"\\","/")+"/*"
|
|
}
|
|
return nil
|
|
})
|
|
os.RemoveAll(name)
|
|
}else{
|
|
o,e := exec.Command(filepath.Join(rootDir,"sdelete64.exe"),name,"-p","4").Output()
|
|
fmt.Println(string(o),e)
|
|
shredDone++
|
|
shredUpdate(separate)
|
|
}
|
|
}
|
|
fmt.Println(name)
|
|
g.Update()
|
|
}
|
|
/*if itemSelected==1&&runtime.GOOS=="windows"{
|
|
cmd := exec.Command("cipher","/w:\""+name+"\"")
|
|
stdout,err := cmd.Output()
|
|
if err!=nil{
|
|
fmt.Println(err)
|
|
}
|
|
fmt.Println(string(stdout))
|
|
}*/
|
|
shredding = "Ready."
|
|
shredProgress = 0
|
|
shredOverlay = ""
|
|
}
|
|
|
|
func shredUpdate(separate bool){
|
|
if separate{
|
|
shredOverlay = fmt.Sprintf("%d/%d",int(shredDone),int(shredTotal))
|
|
shredProgress = shredDone/shredTotal
|
|
}else{
|
|
status = fmt.Sprintf("%d/%d",int(shredDone),int(shredTotal))
|
|
progress = shredDone/shredTotal
|
|
}
|
|
g.Update()
|
|
}
|
|
|
|
// Generate file checksums
|
|
func generateChecksums(file string){
|
|
fin,_ := os.Open(file)
|
|
|
|
cs_md5 = ""
|
|
cs_sha1 = ""
|
|
cs_sha256 = ""
|
|
cs_sha3_256 = ""
|
|
cs_blake2b = ""
|
|
cs_blake2s = ""
|
|
cs_blake3 = ""
|
|
|
|
if md5_selected{
|
|
cs_md5 = "Calculating..."
|
|
}
|
|
if sha1_selected{
|
|
cs_sha1 = "Calculating..."
|
|
}
|
|
if sha256_selected{
|
|
cs_sha256 = "Calculating..."
|
|
}
|
|
if sha3_256_selected{
|
|
cs_sha3_256 = "Calculating..."
|
|
}
|
|
if blake2b_selected{
|
|
cs_blake2b = "Calculating..."
|
|
}
|
|
if blake2s_selected{
|
|
cs_blake2s = "Calculating..."
|
|
}
|
|
if blake3_selected{
|
|
cs_blake3 = "Calculating..."
|
|
}
|
|
|
|
crc_md5 := md5.New()
|
|
crc_sha1 := sha1.New()
|
|
crc_sha256 := sha256.New()
|
|
crc_sha3_256 := sha3.New256()
|
|
crc_blake2b,_ := blake2b.New256(nil)
|
|
crc_blake2s,_ := blake2s.New256(nil)
|
|
crc_blake3 := blake3.New()
|
|
stat,_ := os.Stat(file)
|
|
total := stat.Size()
|
|
var done int64 = 0
|
|
for{
|
|
var data []byte
|
|
_data := make([]byte,1048576)
|
|
size,err := fin.Read(_data)
|
|
if err!=nil{
|
|
break
|
|
}
|
|
data = _data[:size]
|
|
|
|
if md5_selected{
|
|
crc_md5.Write(data)
|
|
}
|
|
if sha1_selected{
|
|
crc_sha1.Write(data)
|
|
}
|
|
if sha256_selected{
|
|
crc_sha256.Write(data)
|
|
}
|
|
if sha3_256_selected{
|
|
crc_sha3_256.Write(data)
|
|
}
|
|
if blake2b_selected{
|
|
crc_blake2b.Write(data)
|
|
}
|
|
if blake2s_selected{
|
|
crc_blake2s.Write(data)
|
|
}
|
|
if blake3_selected{
|
|
crc_blake3.Write(data)
|
|
}
|
|
|
|
done += int64(size)
|
|
cs_progress = float32(done)/float32(total)
|
|
g.Update()
|
|
}
|
|
cs_progress = 0
|
|
if md5_selected{
|
|
cs_md5 = hex.EncodeToString(crc_md5.Sum(nil))
|
|
}
|
|
if sha1_selected{
|
|
cs_sha1 = hex.EncodeToString(crc_sha1.Sum(nil))
|
|
}
|
|
if sha256_selected{
|
|
cs_sha256 = hex.EncodeToString(crc_sha256.Sum(nil))
|
|
}
|
|
if sha3_256_selected{
|
|
cs_sha3_256 = hex.EncodeToString(crc_sha3_256.Sum(nil))
|
|
}
|
|
if blake2b_selected{
|
|
cs_blake2b = hex.EncodeToString(crc_blake2b.Sum(nil))
|
|
}
|
|
if blake2s_selected{
|
|
cs_blake2s = hex.EncodeToString(crc_blake2s.Sum(nil))
|
|
}
|
|
if blake3_selected{
|
|
cs_blake3 = hex.EncodeToString(crc_blake3.Sum(nil))
|
|
}
|
|
g.Update()
|
|
}
|
|
|
|
|
|
// Reset the UI to a clean state with no nothing selected
|
|
func resetUI(){
|
|
inputLabel = "Drag and drop file(s) and folder(s) into this window."
|
|
outputEntry = ""
|
|
orLabel = "or"
|
|
outputWidth = 376
|
|
password = ""
|
|
cPassword = ""
|
|
keyfilePrompt = "Keyfile (optional):"
|
|
keyfileLabel = "Use a keyfile"
|
|
keyfile = false
|
|
metadata = ""
|
|
keep = false
|
|
erase = false
|
|
reedsolo = false
|
|
split = false
|
|
splitSize = ""
|
|
fast = false
|
|
progress = 0
|
|
progressInfo = ""
|
|
_status = ""
|
|
_status_color = color.RGBA{0xff,0xff,0xff,255}
|
|
g.Update()
|
|
}
|
|
|
|
func broken(){
|
|
working = false
|
|
_status = "The file is either corrupted or intentionally modified."
|
|
_status_color = color.RGBA{0xff,0x00,0x00,255}
|
|
os.Remove(outputFile)
|
|
debug.FreeOSMemory()
|
|
}
|
|
|
|
func rsEncode(data []byte,encoder reedsolomon.Encoder,size int) []byte{
|
|
shards,_ := encoder.Split(data)
|
|
encoder.Encode(shards)
|
|
tmp := make([]byte,size)
|
|
for i,shard := range(shards){
|
|
tmp[i] = shard[0]
|
|
}
|
|
return tmp
|
|
}
|
|
|
|
func rsDecode(data []byte,encoder reedsolomon.Encoder,size int) []byte{
|
|
res := make([][]byte,len(data))
|
|
for i,_ := range(data){
|
|
tmp := make([]byte,1)
|
|
tmp[0] = data[i]
|
|
res[i] = tmp
|
|
}
|
|
_ = encoder.Reconstruct(res)
|
|
res = res[:size]
|
|
tmp := make([]byte,size)
|
|
for i,shard := range(res){
|
|
tmp[i] = shard[0]
|
|
}
|
|
return tmp
|
|
}
|
|
|
|
// Create the master window, set callbacks, and start the UI
|
|
func main(){
|
|
di.Init()
|
|
if runtime.GOOS=="windows"{
|
|
exec.Command(filepath.Join(rootDir,"sdelete64.exe"),"/accepteula")
|
|
}
|
|
window := g.NewMasterWindow("Picocrypt",480,488,g.MasterWindowFlagsNotResizable,nil)
|
|
window.SetDropCallback(onDrop)
|
|
dpi = g.Context.GetPlatform().GetContentScale()
|
|
window.Run(startUI)
|
|
}
|