package main

import (
  "crypto/aes"
  "crypto/cipher"
  "crypto/rand"
  "fmt"
  "io"
  "log"
)

type cfb8 struct {
  b         cipher.Block
  blockSize int
  in        []byte
  out       []byte

  decrypt bool
}

var plaintext string = "平文の文字列"

func main() {
  key := []byte("0123456789ABCDEF")
  block, err := aes.NewCipher(key)
  if err != nil {
    panic(err)
  }

  ciphertext := make([]byte, aes.BlockSize+len(plaintext))
  iv := ciphertext[:aes.BlockSize]

  if _, err = io.ReadFull(rand.Reader, iv); err != nil {
    panic(err)
  }

  stream := newCFB8Encrypter(block, iv)
  stream.XORKeyStream(ciphertext[aes.BlockSize:], []byte(plaintext))
  fmt.Printf("Encrypted result:%x\n", plaintext)

  stream = newCFB8Decrypter(block, iv)
  stream.XORKeyStream([]byte(plaintext), ciphertext[aes.BlockSize:])
  fmt.Printf("Decrypted result:%s\n", plaintext)
}

func newCFB8Encrypter(block cipher.Block, iv []byte) cipher.Stream {
  return newCFB8(block, iv, false)
}

func newCFB8Decrypter(block cipher.Block, iv []byte) cipher.Stream {
  return newCFB8(block, iv, true)
}

func newCFB8(block cipher.Block, iv []byte, decrypt bool) cipher.Stream {
  blockSize := block.BlockSize()

  if len(iv) != blockSize {
    panic("cipher.newCFB: IV length must equal block size")
  }
  x := &cfb8{
    b:         block,
    blockSize: blockSize,
    out:       make([]byte, blockSize),
    in:        make([]byte, blockSize),
    decrypt:   decrypt,
  }
  copy(x.in, iv)

  return x
}

func (x *cfb8) XORKeyStream(dst, src []byte) {
  for i := range src {
    x.b.Encrypt(x.out, x.in)
    copy(x.in[:x.blockSize-1], x.in[1:])
    if x.decrypt {
      x.in[x.blockSize-1] = src[i]
    }
    dst[i] = src[i] ^ x.out[0]
    if !x.decrypt {
      x.in[x.blockSize-1] = dst[i]
    }
  }
}