aes.go

package main

import (
	"crypto/aes"
	"crypto/cipher"
	"crypto/rand"
	"errors"
	"flag"
	"fmt"
	"io"
	"io/ioutil"
	"os"
)

func encrypt(key, data []byte) ([]byte, error) {
	block, err := aes.NewCipher(key)
	if err != nil {
		return nil, err
	}
	buffer := make([]byte, aes.BlockSize+len(data))
	iv := buffer[:aes.BlockSize]
	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
		return nil, err
	}
	cfb := cipher.NewCFBEncrypter(block, iv)
	cfb.XORKeyStream(buffer[aes.BlockSize:], []byte(data))
	return buffer, nil
}

func decrypt(key, data []byte) ([]byte, error) {
	block, err := aes.NewCipher(key)
	if err != nil {
		return nil, err
	}
	if len(data) < aes.BlockSize {
		return nil, errors.New("data too short")
	}
	iv := data[:aes.BlockSize]
	data = data[aes.BlockSize:]
	cfb := cipher.NewCFBDecrypter(block, iv)
	cfb.XORKeyStream(data, data)
	return data, nil
}

func handleFile(src, dst string, key string, enc bool) error {
	buffer, err := ioutil.ReadFile(src)
	if err != nil {
		return err
	}

	if enc {
		buffer, err = encrypt([]byte(key), buffer)
	} else {
		buffer, err = decrypt([]byte(key), buffer)
	}
	if err != nil {
		return err
	}

	ioutil.WriteFile(dst, buffer, 0644)
	if err != nil {
		return err
	}

	return nil
}

func main() {
	dec := flag.Bool("d", false, "decrypt")
	enc := flag.Bool("e", false, "encrypt")
	key := flag.String("k", "", "key")

	flag.Parse()

	if !(*dec || *enc) || len(*key) == 0 || len(flag.Args()) != 2 {
		fmt.Fprintln(os.Stderr, "usage:", os.Args[0], "[-d|-e] [-k KEY] <inputfile> <outputfile>")
		flag.PrintDefaults()
		os.Exit(0)
	}

	if err := handleFile(flag.Args()[0], flag.Args()[1], *key, *enc); err != nil {
		panic(err)
	}
}