本文已参与「新人创作礼」活动，一起开启掘金创作之路。

准备阶段

1、密钥p生成规则

写一个质数p选择方法，找到一个相对较大的质数（11位左右）作为p。或者利用网上工具找到这个质数p

代码如下：

package DSA

//生成质数
func PrimeCount (x int64) int64 {
   var i int64
   for i = 11; i < x/2; i++ {
   //从11开始只是为了更快的过滤掉非质数。要更高级的话可以写一个数组存放多个素数循环进行判断，把素数的特性发挥出来。
      if x%2==0||x%3==0||x%5==0||x%7==0{
         x++
         return PrimeCount(x)
      }else if x%i==0{
         x++
         return PrimeCount(x)
      }
   }
   return x
}

2、使用MD5或者sha256进行加密

代码如下： go是一个加密函数十分友好的语言，可以进行调包。

1、MD5加密

package DSA

import (
   "crypto/md5"
   "encoding/hex"
)

func Md5(str string) string {
   h := md5.New()
   h.Write([]byte(str))
   return hex.EncodeToString(h.Sum(nil))
}

2、sha256加密

sha256也可以调包，两行代码解决。（但还是可以看看原理）

package DSA

import (
   "encoding/binary"
)

const Size = 32
const (
   chunk     = 64
   //八个哈希常量初始值
   init0     = 0x6A09E667
   init1     = 0xBB67AE85
   init2     = 0x3C6EF372
   init3     = 0xA54FF53A
   init4     = 0x510E527F
   init5     = 0x9B05688C
   init6     = 0x1F83D9AB
   init7     = 0x5BE0CD19
   init0_224 = 0xC1059ED8
   init1_224 = 0x367CD507
   init2_224 = 0x3070DD17
   init3_224 = 0xF70E5939
   init4_224 = 0xFFC00B31
   init5_224 = 0x68581511
   init6_224 = 0x64F98FA7
   init7_224 = 0xBEFA4FA4
)

type digest struct {
   h     [8]uint32
   x     [chunk]byte
   nx    int
   len   uint64
   is224 bool // mark if this digest is SHA-224
}

func block(dig *digest, p []byte){}

func (d *digest) Reset() {
   if !d.is224 {
      d.h[0] = init0
      d.h[1] = init1
      d.h[2] = init2
      d.h[3] = init3
      d.h[4] = init4
      d.h[5] = init5
      d.h[6] = init6
      d.h[7] = init7
   } else {
      d.h[0] = init0_224
      d.h[1] = init1_224
      d.h[2] = init2_224
      d.h[3] = init3_224
      d.h[4] = init4_224
      d.h[5] = init5_224
      d.h[6] = init6_224
      d.h[7] = init7_224
   }
   d.nx = 0
   d.len = 0
}

func (d *digest) checkSum() [Size]byte {
   len := d.len
   // Padding. Add a 1 bit and 0 bits until 56 bytes mod 64.
   var tmp [64]byte
   tmp[0] = 0x80
   if len%64 < 56 {
      d.Write(tmp[0 : 56-len%64])
   } else {
      d.Write(tmp[0 : 64+56-len%64])
   }

   // Length in bits.
   len <<= 3
   binary.BigEndian.PutUint64(tmp[:], len)
   d.Write(tmp[0:8])

   if d.nx != 0 {
      panic("d.nx != 0")
   }

   var digest [Size]byte

   binary.BigEndian.PutUint32(digest[0:], d.h[0])
   binary.BigEndian.PutUint32(digest[4:], d.h[1])
   binary.BigEndian.PutUint32(digest[8:], d.h[2])
   binary.BigEndian.PutUint32(digest[12:], d.h[3])
   binary.BigEndian.PutUint32(digest[16:], d.h[4])
   binary.BigEndian.PutUint32(digest[20:], d.h[5])
   binary.BigEndian.PutUint32(digest[24:], d.h[6])
   if !d.is224 {
      binary.BigEndian.PutUint32(digest[28:], d.h[7])
   }

   return digest
}
func (d *digest) Write(p []byte) (nn int, err error) {
   nn = len(p)
   d.len += uint64(nn)
   if d.nx > 0 {
      n := copy(d.x[d.nx:], p)
      d.nx += n
      if d.nx == chunk {
         block(d, d.x[:])
         d.nx = 0
      }
      p = p[n:]
   }
   if len(p) >= chunk {
      n := len(p) &^ (chunk - 1)
      block(d, p[:n])
      p = p[n:]
   }
   if len(p) > 0 {
      d.nx = copy(d.x[:], p)
   }
   return
}
func Sum256(data []byte) [Size]byte {
   var d digest
   d.Reset()
   d.Write(data)
   return d.checkSum()
}