9.6 Encrypting and decrypting data

The previous section describes how to securely store passwords, but sometimes it might be neccessary to modify some sensitive encrypted data that has already been stored into our database. When data decryption is required, we should use a symmetric encryption algorithm instead of the one-way hashing techniques we’ve previously covered.

Advanced encryption and decryption

The Go language supports symmetric encryption algorithms in its crypto package. Do not use anything except AES in GCM mode if you don’t know what you’re doing!

  • crypto/aes package: AES (Advanced Encryption Standard), also known as Rijndael encryption method, is used by the U.S. federal government as a block encryption standard.

In the following example we demonstrate how to encrypt data using AES in GCM mode:

  1. package main
  3. import (
  4.     "crypto/aes"
  5.     "crypto/cipher"
  6.     "crypto/rand"
  7.     "errors"
  8.     "fmt"
  9.     "io"
  10.     "log"
  11. )
  13. func main() {
  14.     text := []byte("My name is Astaxie")
  15.     key := []byte("the-key-has-to-be-32-bytes-long!")
  17.     ciphertext, err := encrypt(text, key)
  18.     if err != nil {
  19.         // TODO: Properly handle error
  20.         log.Fatal(err)
  21.     }
  22.     fmt.Printf("%s => %x\n", text, ciphertext)
  24.     plaintext, err := decrypt(ciphertext, key)
  25.     if err != nil {
  26.         // TODO: Properly handle error
  27.         log.Fatal(err)
  28.     }
  29.     fmt.Printf("%x => %s\n", ciphertext, plaintext)
  30. }
  32. func encrypt(plaintext []byte, key []byte) ([]byte, error) {
  33.     c, err := aes.NewCipher(key)
  34.     if err != nil {
  35.         return nil, err
  36.     }
  38.     gcm, err := cipher.NewGCM(c)
  39.     if err != nil {
  40.         return nil, err
  41.     }
  43.     nonce := make([]byte, gcm.NonceSize())
  44.     if _, err = io.ReadFull(rand.Reader, nonce); err != nil {
  45.         return nil, err
  46.     }
  48.     return gcm.Seal(nonce, nonce, plaintext, nil), nil
  49. }
  51. func decrypt(ciphertext []byte, key []byte) ([]byte, error) {
  52.     c, err := aes.NewCipher(key)
  53.     if err != nil {
  54.         return nil, err
  55.     }
  57.     gcm, err := cipher.NewGCM(c)
  58.     if err != nil {
  59.         return nil, err
  60.     }
  62.     nonceSize := gcm.NonceSize()
  63.     if len(ciphertext) < nonceSize {
  64.         return nil, errors.New("ciphertext too short")
  65.     }
  67.     nonce, ciphertext := ciphertext[:nonceSize], ciphertext[nonceSize:]
  68.     return gcm.Open(nil, nonce, ciphertext, nil)
  69. }

Calling the above function aes.NewCipher (whose []byte key parameter must be 16, 24 or 32, corresponding to the AES-128, AES-192 or AES-256 algorithms, respectively), returns a cipher.Block Interface that implements three functions:

  1. type Block interface {
  2.     // BlockSize returns the cipher's block size.
  3.     BlockSize() int
  5.     // Encrypt encrypts the first block in src into dst.
  6.     // Dst and src may point at the same memory.
  7.     Encrypt(dst, src []byte)
  9.     // Decrypt decrypts the first block in src into dst.
  10.     // Dst and src may point at the same memory.
  11.     Decrypt(dst, src []byte)
  12. }

These three functions implement encryption and decryption operations; see the Go documentation for a more detailed explanation.

Summary

This section describes encryption algorithms which can be used in different ways according to your web application’s encryption and decryption needs. For applications with even basic security requirements it is recommended to use AES in GCM mode.