itsbalamurali · January 29, 2018 02:38 · Sep 10, 2014 · Sep 10, 2014 · Sep 9, 2014 · Sep 7, 2014
diff --git a/simple.go → simple-gpg-enc.go b/simple.go → simple-gpg-enc.go
diff --git a/simple.go b/simple.go
@@ -1,61 +1,123 @@
 package main
 
 import (
-	"log"
-	"bytes"
-	"code.google.com/p/go.crypto/openpgp"
-	"encoding/base64"
-	"io/ioutil"
-	"os"
+    "bytes"
+    "code.google.com/p/go.crypto/openpgp"
+    "encoding/base64"
+    "io/ioutil"
+    "log"
+    "os"
 )
 
 // create gpg keys with
 // $ gpg --gen-key
 // ensure you correct paths and passphrase
 
-const mysecretstring = "this is so very secret!"
-const secretKeyring = "/Users/stuart-warren/.gnupg/secring.gpg"
-const publicKeyring = "/Users/stuart-warren/.gnupg/pubring.gpg"
-const passphrase = "1234"
+const mySecretString = "this is so very secret!"
+const prefix, passphrase = "/Users/stuart-warren/", "1234"
+const secretKeyring = prefix + ".gnupg/secring.gpg"
+const publicKeyring = prefix + ".gnupg/pubring.gpg"
+
+func encTest(secretString string) (string, error) {
+    log.Println("Secret to hide:", secretString)
+    log.Println("Public Keyring:", publicKeyring)
+
+    // Read in public key
+    keyringFileBuffer, _ := os.Open(publicKeyring)
+    defer keyringFileBuffer.Close()
+    entityList, err := openpgp.ReadKeyRing(keyringFileBuffer)
+    if err != nil {
+        return "", err
+    }
+
+    // encrypt string
+    buf := new(bytes.Buffer)
+    w, err := openpgp.Encrypt(buf, entityList, nil, nil, nil)
+    if err != nil {
+        return "", err
+    }
+    _, err = w.Write([]byte(mySecretString))
+    if err != nil {
+        return "", err
+    }
+    err = w.Close()
+    if err != nil {
+        return "", err
+    }
+
+    // Encode to base64
+    bytes, err := ioutil.ReadAll(buf)
+    if err != nil {
+        return "", err
+    }
+    encStr := base64.StdEncoding.EncodeToString(bytes)
+
+    // Output encrypted/encoded string
+    log.Println("Encrypted Secret:", encStr)
+
+    return encStr, nil
+}
+
+func decTest(encString string) (string, error) {
+
+    log.Println("Secret Keyring:", secretKeyring)
+    log.Println("Passphrase:", passphrase)
+
+    // init some vars
+    var entity *openpgp.Entity
+    var entityList openpgp.EntityList
+
+    // Open the private key file
+    keyringFileBuffer, err := os.Open(secretKeyring)
+    if err != nil {
+        return "", err
+    }
+    defer keyringFileBuffer.Close()
+    entityList, err = openpgp.ReadKeyRing(keyringFileBuffer)
+    if err != nil {
+        return "", err
+    }
+    entity = entityList[0]
+
+    // Get the passphrase and read the private key.
+    // Have not touched the encrypted string yet
+    passphraseByte := []byte(passphrase)
+    log.Println("Decrypting private key using passphrase")
+    entity.PrivateKey.Decrypt(passphraseByte)
+    for _, subkey := range entity.Subkeys {
+        subkey.PrivateKey.Decrypt(passphraseByte)
+    }
+    log.Println("Finished decrypting private key using passphrase")
+
+    // Decode the base64 string
+    dec, err := base64.StdEncoding.DecodeString(encString)
+    if err != nil {
+        return "", err
+    }
+
+    // Decrypt it with the contents of the private key
+    md, err := openpgp.ReadMessage(bytes.NewBuffer(dec), entityList, nil, nil)
+    if err != nil {
+        return "", err
+    }
+    bytes, err := ioutil.ReadAll(md.UnverifiedBody)
+    if err != nil {
+        return "", err
+    }
+    decStr := string(bytes)
+
+    return decStr, nil
+}
 
 func main() {
-	log.Printf("Secret: ", mysecretstring)
-	log.Printf("Secret Keyring: ", secretKeyring)
-	log.Printf("Public Keyring: ", publicKeyring)
-	log.Printf("Passphrase: ", passphrase)
-
-	keyringFileBuffer, _ := os.Open(publicKeyring)
-	defer keyringFileBuffer.Close()
-	entitylist, _ := openpgp.ReadKeyRing(keyringFileBuffer)
-
-	buf := new(bytes.Buffer)
-	w, _ := openpgp.Encrypt(buf, entitylist, nil, nil, nil)
-	w.Write([]byte(mysecretstring))
-	bytesp, _ := ioutil.ReadAll(buf)
-	encstr := base64.StdEncoding.EncodeToString(bytesp)
-
-	log.Printf("Encrypted Secret: ", encstr)
-
-	var entity2 *openpgp.Entity
-	var entitylist2 openpgp.EntityList
-
-	keyringFileBuffer2, _ := os.Open(secretKeyring)
-	defer keyringFileBuffer2.Close()
-	entitylist2, _ = openpgp.ReadKeyRing(keyringFileBuffer2)
-	entity2 = entitylist2[0]
-
-	passphrasebyte := []byte(passphrase)
-	log.Printf("Decrypting private key using passphrase")
-	entity2.PrivateKey.Decrypt(passphrasebyte)
-	for _, subkey := range entity2.Subkeys {
-			subkey.PrivateKey.Decrypt(passphrasebyte)
-	}
-	log.Printf("Finished decrypting private key using passphrase")
-
-	dec, _ := base64.StdEncoding.DecodeString(encstr)
-	md, _ := openpgp.ReadMessage(bytes.NewBuffer(dec), entitylist2, nil, nil)
-	bytess, _ := ioutil.ReadAll(md.UnverifiedBody)
-	decstr := string(bytess)
-	log.Printf("Decrypted Secret: ", decstr)
-
-}
+    encStr, err := encTest(mySecretString)
+    if err != nil {
+        log.Fatal(err)
+    }
+    decStr, err := decTest(encStr)
+    if err != nil {
+        log.Fatal(err)
+    }
+    // should be done
+    log.Println("Decrypted Secret:", decStr)
+}
diff --git a/simple.go b/simple.go
@@ -9,9 +9,9 @@ import (
 	"os"
 )
 
-# create gpg keys with
-# $ gpg --gen-key
-# ensure you correct paths and passphrase
+// create gpg keys with
+// $ gpg --gen-key
+// ensure you correct paths and passphrase
 
 const mysecretstring = "this is so very secret!"
 const secretKeyring = "/Users/stuart-warren/.gnupg/secring.gpg"

diff --git a/simple → simple.go b/simple → simple.go
diff --git a/simple b/simple
@@ -0,0 +1,61 @@
+package main
+
+import (
+	"log"
+	"bytes"
+	"code.google.com/p/go.crypto/openpgp"
+	"encoding/base64"
+	"io/ioutil"
+	"os"
+)
+
+# create gpg keys with
+# $ gpg --gen-key
+# ensure you correct paths and passphrase
+
+const mysecretstring = "this is so very secret!"
+const secretKeyring = "/Users/stuart-warren/.gnupg/secring.gpg"
+const publicKeyring = "/Users/stuart-warren/.gnupg/pubring.gpg"
+const passphrase = "1234"
+
+func main() {
+	log.Printf("Secret: ", mysecretstring)
+	log.Printf("Secret Keyring: ", secretKeyring)
+	log.Printf("Public Keyring: ", publicKeyring)
+	log.Printf("Passphrase: ", passphrase)
+
+	keyringFileBuffer, _ := os.Open(publicKeyring)
+	defer keyringFileBuffer.Close()
+	entitylist, _ := openpgp.ReadKeyRing(keyringFileBuffer)
+
+	buf := new(bytes.Buffer)
+	w, _ := openpgp.Encrypt(buf, entitylist, nil, nil, nil)
+	w.Write([]byte(mysecretstring))
+	bytesp, _ := ioutil.ReadAll(buf)
+	encstr := base64.StdEncoding.EncodeToString(bytesp)
+
+	log.Printf("Encrypted Secret: ", encstr)
+
+	var entity2 *openpgp.Entity
+	var entitylist2 openpgp.EntityList
+
+	keyringFileBuffer2, _ := os.Open(secretKeyring)
+	defer keyringFileBuffer2.Close()
+	entitylist2, _ = openpgp.ReadKeyRing(keyringFileBuffer2)
+	entity2 = entitylist2[0]
+
+	passphrasebyte := []byte(passphrase)
+	log.Printf("Decrypting private key using passphrase")
+	entity2.PrivateKey.Decrypt(passphrasebyte)
+	for _, subkey := range entity2.Subkeys {
+			subkey.PrivateKey.Decrypt(passphrasebyte)
+	}
+	log.Printf("Finished decrypting private key using passphrase")
+
+	dec, _ := base64.StdEncoding.DecodeString(encstr)
+	md, _ := openpgp.ReadMessage(bytes.NewBuffer(dec), entitylist2, nil, nil)
+	bytess, _ := ioutil.ReadAll(md.UnverifiedBody)
+	decstr := string(bytess)
+	log.Printf("Decrypted Secret: ", decstr)
+
+}
No results found