Encryption

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

  package main

  import (
          "fmt"
          "crypto/md5"
          "crypto/aes"
          "crypto/cipher"
          "crypto/rand"
          "io"
          "encoding/hex"
  )

  func createHash(key string) string {
          hashstr := md5.New()
          hashstr.Write([]byte(key))
          return hex.EncodeToString(hashstr.Sum(nil))
  }

  func encrypt(data []byte, passphrase string) []byte {
          block, _ := aes.NewCipher([]byte(createHash(passphrase)))
          gcm, err := cipher.NewGCM(block)

          if err != nil {
                  panic(err.Error())
          }

          nonce := make([]byte, gcm.NonceSize())
          if _, err = io.ReadFull(rand.Reader, nonce);err != nil {
                  panic(err.Error())
          }

          ciphertext := gcm.Seal(nonce, nonce, data, nil)
          return ciphertext
  }

  func decrypt(data []byte, passphrase string) []byte {
          key := []byte(createHash(passphrase))
          block, err := aes.NewCipher(key)
          if err != nil {
                  panic(err.Error())
          }

          gcm, err := cipher.NewGCM(block)
          if err != nil {
                  panic(err.Error())
          }

          nonceSize := gcm.NonceSize()
          nonce, ciphertext := data[:nonceSize], data[nonceSize:]

          plaintext, err := gcm.Open(nil, nonce, ciphertext, nil)
          if err != nil {
                  panic(err.Error())
          }

          return plaintext
  }

  func main() {
          encryptr := encrypt([]byte("hello, liuliancao!"),"liuliancao@liuliancao.com")
          fmt.Printf("encrypt strings: %x\n", encryptr)
          plaintext := decrypt([]byte(encryptr), "liuliancao@liuliancao.com")
          fmt.Printf("decrypt strings: %s\n", plaintext)
  }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

  package main

  import (
          "crypto/sha256"
          "crypto/md5"
          "fmt"
  )

  func main() {
          h := sha256.New()
          h.Write([]byte("wagent@"))

          m := md5.New()
          m.Write([]byte("guarder"))
          fmt.Printf("%x,%d\n", h.Sum(nil),len(h.Sum(nil)))
          fmt.Printf("%x,%d\n", m.Sum(nil),len(m.Sum(nil)))
  }