diff --git a/main.go b/main.go
index 7d9425e..7a98a2f 100644
--- a/main.go
+++ b/main.go
@@ -1,6 +1,7 @@
 package main
 
 import (
+	"errors"
 	"flag"
 	"io"
 	"log"
@@ -60,88 +61,17 @@ func main() {
 		log.Fatal("DstFile has Exists if override add flag -y ")
 	}
 
-	// go to decrypt file
-	if flags.Decrypt {
-		decryptAction()
-	}
+	flags.KeyFile = tools.ParsePath(flags.KeyFile)
+	flags.SrcFile = tools.ParsePath(flags.SrcFile)
+	flags.DstFile = tools.ParsePath(flags.DstFile)
+
 	if flags.Encrypt {
 		// encryptAction()
 		encrypt()
 	}
-}
-
-func decryptAction() {
-	// open key file
-	keyFile, err := os.Open(flags.KeyFile)
-	handleError(err)
-	defer keyFile.Close()
-
-	keys, err := pgpcrypt.ReadKeyFile(keyFile)
-	handleError(err)
-	if len(keys) == 0 {
-		log.Fatal("key file not validate")
+	if flags.Decrypt {
+		decrypt()
 	}
-
-	srcFile, err := os.Open(flags.SrcFile)
-	handleError(err)
-
-	var dstFile *os.File
-	if tools.CheckExists(flags.DstFile, false) {
-		dstFile, err = os.Open(flags.DstFile)
-		handleError(err)
-		defer dstFile.Close()
-		dstStat, err := dstFile.Stat()
-		handleError(err)
-		err = dstFile.Truncate(dstStat.Size())
-		handleError(err)
-	} else {
-		dstFile, err = os.Create(flags.DstFile)
-		handleError(err)
-		defer dstFile.Close()
-	}
-
-	key := keys[0]
-	err = pgpcrypt.Decrypt(key, flags.Password, srcFile, dstFile)
-	handleError(err)
-}
-
-func encryptAction() {
-	// open key file
-	keyFile, err := os.Open(flags.KeyFile)
-	handleError(err)
-	defer keyFile.Close()
-
-	keys, err := pgpcrypt.ReadKeyFile(keyFile)
-	handleError(err)
-	if len(keys) == 0 {
-		log.Fatal("key file not validate")
-	}
-
-	srcFile, err := os.Open(flags.SrcFile)
-	handleError(err)
-
-	// encBytes, err := pgpcrypt.EncryptBytes(keys, srcFile)
-	// handleError(err)
-
-	// fmt.Println("bytes ::: ", len(encBytes))
-
-	// var dstFile *os.File
-	// if tools.CheckExists(flags.DstFile, false) {
-	// 	dstFile, err = os.Open(flags.DstFile)
-	// 	handleError(err)
-	// 	defer dstFile.Close()
-	// 	dstStat, err := dstFile.Stat()
-	// 	handleError(err)
-	// 	err = dstFile.Truncate(dstStat.Size())
-	// 	handleError(err)
-	// } else {
-	dstFile, err := os.Create(flags.DstFile)
-	handleError(err)
-	defer dstFile.Close()
-	// }
-
-	err = pgpcrypt.Encrypt(keys, srcFile, dstFile)
-	handleError(err)
 }
 
 func handleError(err error) {
@@ -154,48 +84,63 @@ func showUsage() {
 	flag.Usage()
 }
 
-func encrypt() {
+func decrypt() {
 	keyFile, err := os.Open(flags.KeyFile)
-	if err != nil {
-		log.Fatal(err)
-	}
+	handleError(err)
 	defer keyFile.Close()
 
-	var keyList openpgp.EntityList
-	keys, err := openpgp.ReadArmoredKeyRing(keyFile)
-	// keys, err := openpgp.ReadKeyRing(keyFile)
-	if err != nil {
-		log.Fatal(err)
+	keyList, err := pgpcrypt.ReadKeyFile(keyFile)
+	handleError(err)
+	if len(keyList) == 0 {
+		handleError(errors.New("key not found"))
 	}
 
-	keyList = append(keyList, keys...)
+	key := keyList[0]
 
-	distFile, err := os.Create(flags.DstFile)
-	if err != nil {
-		log.Fatal(err)
+	passphraseByte := []byte(flags.Password)
+	key.PrivateKey.Decrypt(passphraseByte)
+	for _, sub := range key.Subkeys {
+		sub.PrivateKey.Decrypt(passphraseByte)
 	}
-	defer distFile.Close()
 
-	// distBuf := new(bytes.Buffer)
+	dstFile, err := os.Create(flags.DstFile)
+	handleError(err)
+	defer dstFile.Close()
 
 	srcFile, err := os.Open(flags.SrcFile)
-	if err != nil {
-		log.Fatal(err)
-	}
+	handleError(err)
+	defer srcFile.Close()
+
+	md, err := openpgp.ReadMessage(srcFile, keyList, nil, nil)
+
+	_, err = io.Copy(dstFile, md.UnverifiedBody)
+	handleError(err)
+}
+
+func encrypt() {
+	keyFile, err := os.Open(flags.KeyFile)
+	handleError(err)
+	defer keyFile.Close()
+
+	keyList, err := pgpcrypt.ReadKeyFile(keyFile)
+	handleError(err)
+
+	distFile, err := os.Create(flags.DstFile)
+	handleError(err)
+	defer distFile.Close()
+
+	srcFile, err := os.Open(flags.SrcFile)
+	handleError(err)
 	defer srcFile.Close()
 
 	fhint := &openpgp.FileHints{}
 	fhint.IsBinary = true
 
 	tmpWriter, err := openpgp.Encrypt(distFile, keyList, nil, fhint, nil)
-	if err != nil {
-		log.Fatal(err)
-	}
+	handleError(err)
 	defer tmpWriter.Close()
 
 	_, err = io.Copy(tmpWriter, srcFile)
-	if err != nil {
-		log.Fatal(err)
-	}
+	handleError(err)
 
 }
diff --git a/pgpcrypt/crypt.go b/pgpcrypt/crypt.go
deleted file mode 100644
index 6b6ff72..0000000
--- a/pgpcrypt/crypt.go
+++ /dev/null
@@ -1,79 +0,0 @@
-package pgpcrypt
-
-import (
-	"bytes"
-	"io"
-	"io/ioutil"
-	"time"
-
-	"golang.org/x/crypto/openpgp"
-)
-
-// Encrypt - pgp encrypt func
-func Encrypt(key openpgp.EntityList, src io.Reader, dst io.Writer) error {
-	fileHint := &openpgp.FileHints{}
-	fileHint.IsBinary = true
-	fileHint.ModTime = time.Now()
-
-	encWriter, err := openpgp.Encrypt(dst, key, nil, fileHint, nil)
-	if err != nil {
-		return err
-	}
-
-	_, err = io.Copy(encWriter, src)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// EncryptBytes -
-func EncryptBytes(key openpgp.EntityList, src io.Reader) ([]byte, error) {
-	buf := new(bytes.Buffer)
-
-	fileHint := &openpgp.FileHints{}
-	fileHint.IsBinary = true
-
-	encWriter, err := openpgp.Encrypt(buf, key, nil, fileHint, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	_, err = io.Copy(encWriter, src)
-	if err != nil {
-		return nil, err
-	}
-
-	encBytes, err := ioutil.ReadAll(buf)
-	if err != nil {
-		return nil, err
-	}
-
-	return encBytes, nil
-}
-
-// Decrypt - pgp decrypt func
-func Decrypt(key *openpgp.Entity, keyPassword string, src io.Reader, dst io.Writer) error {
-	// decode private key
-	passphraseByte := []byte(keyPassword)
-	key.PrivateKey.Decrypt(passphraseByte)
-	for _, sub := range key.Subkeys {
-		sub.PrivateKey.Decrypt(passphraseByte)
-	}
-
-	var keyList openpgp.EntityList
-	keyList = append(keyList, key)
-
-	md, err := openpgp.ReadMessage(src, keyList, nil, nil)
-	if err != nil {
-		return err
-	}
-
-	_, err = io.Copy(dst, md.UnverifiedBody)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
diff --git a/pgpcrypt/keys.go b/pgpcrypt/keys.go
index 9fa9f1a..db76a56 100644
--- a/pgpcrypt/keys.go
+++ b/pgpcrypt/keys.go
@@ -9,7 +9,7 @@ import (
 // ReadKeyFile - read key from file
 func ReadKeyFile(r io.Reader) (openpgp.EntityList, error) {
 	keys, err := openpgp.ReadArmoredKeyRing(r)
-	if err != nil {
+	if err != nil || len(keys) == 0 {
 		keys, err = openpgp.ReadKeyRing(r)
 		if err != nil {
 			return nil, err
diff --git a/tools/tools.go b/tools/tools.go
index 1f3c93d..5a43ff5 100644
--- a/tools/tools.go
+++ b/tools/tools.go
@@ -8,7 +8,12 @@ import (
 )
 
 // ParsePath - parse file path to absPath
-func ParsePath(wd, dst string) string {
+func ParsePath(dst string) string {
+	wd, err := os.Getwd()
+	if err != nil {
+		wd = ""
+	}
+
 	if []rune(dst)[0] == '~' {
 		home := UserHomeDir()
 		if len(home) > 0 {
@@ -39,6 +44,7 @@ func UserHomeDir() string {
 
 // CheckExists - check file exists
 func CheckExists(filePath string, allowDir bool) bool {
+	filePath = ParsePath(filePath)
 	stat, err := os.Stat(filePath)
 	if err != nil && !os.IsExist(err) {
 		return false