golang使用opengpg

来源于github

package main

import (
	"fmt"
	"io"
	"io/ioutil"
	"os"
	"strings"

	"golang.org/x/crypto/openpgp"
	"golang.org/x/crypto/openpgp/armor"
	"golang.org/x/crypto/openpgp/packet"
)

// command to generatepublic key in desired format:  gpg --output public.pgp --export your@mail.com
const (
	publicKey = "public.pgp"
	helderKey = "helderPrivateKey.asc"
)

func main() {

	// source file
	sourceBytes, err := ioutil.ReadFile("a1.pdf")

	// destination file
	dst, err := os.Create("a5.pdf.gpg")
	if err != nil {
		panic(err)
	}
	defer dst.Close()

	//read public key
	entityKey, err := readEntity()
	if err != nil {
		fmt.Println(err)
	}

	// encrypt
	erro := encryptFile([]*openpgp.Entity{entityKey}, nil, sourceBytes, dst)

	if erro != nil {
		fmt.Println(erro)
	}

	// decrypt
	decryptFile()

}

func readEntity() (*openpgp.Entity, error) {
	f, err := os.Open(publicKey)
	if err != nil {
		return nil, err
	}
	defer f.Close()
	block, err := armor.Decode(f)
	if err != nil {
		return nil, err
	}
	return openpgp.ReadEntity(packet.NewReader(block.Body))
}

func encryptFile(recip []*openpgp.Entity, signer *openpgp.Entity, r []byte, w io.Writer) error {
	// init some vars
	var entity *openpgp.Entity
	var entityList openpgp.EntityList

	// Open the private key file
	keyringFileBuffer, err := os.Open(helderKey)
	if err != nil {
		fmt.Println(err)
	}
	defer keyringFileBuffer.Close()
	entityList, err = openpgp.ReadKeyRing(keyringFileBuffer)
	if err != nil {
		fmt.Println(err)
	}
	entity = entityList[0]

	passphraseByte := []byte("XXXXXXXXXX")

	entity.PrivateKey.Decrypt(passphraseByte)
	for _, subkey := range entity.Subkeys {
		subkey.PrivateKey.Decrypt(passphraseByte)
	}

	sourceText := string(r)
	wc, err := openpgp.Encrypt(w, recip, entity, &openpgp.FileHints{IsBinary: true}, nil)

	if err != nil {
		return err
	}

	if _, err := io.Copy(wc, strings.NewReader(sourceText)); err != nil {
		return err
	}

	return wc.Close()
}

func decryptFile() error {
	dst, err := os.Open("a6.pdf.sig")
	if err != nil {
		panic(err)
	}
	defer dst.Close()

	// init some vars
	var entityList openpgp.EntityList

	// Open the public key file
	keyringFileBuffer, err := os.Open(publicKey)
	if err != nil {
		fmt.Println(err)
	}
	defer keyringFileBuffer.Close()
	entityList, err = openpgp.ReadKeyRing(keyringFileBuffer)
	if err != nil {
		fmt.Println(err)
	}

	md, err := openpgp.ReadMessage(dst, entityList, nil, nil)
	if err != nil {
		fmt.Println(err)
	}

	entity := md.SignedBy.Entity

	for key := range entity.Identities {
		fmt.Println("Key:", key)
	}

	ww, err := os.Create("a8.pdf")
	if err != nil {
		panic(err)
	}
	defer ww.Close()
	if _, err := io.Copy(ww, md.UnverifiedBody); err != nil {
		fmt.Println(err)
	}

	return nil
}

func signFile(input []byte, output io.Writer, myEntity *openpgp.Entity) error {
	if writeCloser, err := openpgp.Sign(output, myEntity, &openpgp.FileHints{IsBinary: true}, nil); err != nil {
		return err
	} else {
		writeCloser.Write(input)
		return writeCloser.Close()
	}
}