看了2星期的区块链原理与运行机制,加密这里开始变得有些生疏,花了一天时间复习了一些;看到了之前忽略的,也学会了椭圆曲线加密。

//基础板:浅显易懂package main

import (   "crypto/ecdsa"   "crypto/md5"   "encoding/hex"   "fmt"   "math/big"   "strings"

   "crypto/elliptic"   "crypto/rand")

func main() {   src := []byte(string("少壮不努力,活该你单身23333"))   //src1 := []byte(string("少壮不努力,老大徒伤悲3344"))   mysrc := myHash(src)   //mysrc1 := myHash(src1)

   prk, puk, _ := genePriPubKey()   mystring := sign(prk, mysrc)

   r, s := getSign(mystring)

   result := verifySign(&r, &s, mysrc, puk)   fmt.Print(result)

}

func genePriPubKey() (*ecdsa.PrivateKey, ecdsa.PublicKey, error) {

   var err error   var pubkey ecdsa.PublicKey   var prikey *ecdsa.PrivateKey   var curve elliptic.Curve

   curve = elliptic.P384()   prikey, err = ecdsa.GenerateKey(curve, rand.Reader)   if err != nil {      return prikey, pubkey, err   }   pubkey = prikey.PublicKey

   return prikey, pubkey, err}func myHash(src []byte) []byte {   myhash := md5.New()   myhash.Write(src)   return myhash.Sum(nil)}

func sign(key *ecdsa.PrivateKey, myhash []byte) string {   r, s, _ := ecdsa.Sign(rand.Reader, key, myhash)   rm, _ := r.MarshalText()   sm, _ := s.MarshalText()

   return hex.EncodeToString([]byte(string(rm) + "+" + string(sm)))}

func getSign(hexrs string) (rint, sint big.Int) {   st, _ := hex.DecodeString(hexrs)   str := strings.Split(string(st), "+")   _ = rint.UnmarshalText([]byte(str[0]))   //rint是指针:error: invalid memory address or nil pointer dereference   _ = sint.UnmarshalText([]byte(str[1]))

   return}

func verifySign(rint, sint *big.Int, myhash []byte, pubkey ecdsa.PublicKey) bool {   result := ecdsa.Verify(&pubkey, myhash, rint, sint)   return result}

//进阶版:结合gzip/bytes的使用,加入缓冲
package main//https://studygolang.com/articles/13228
//https://blog.csdn.net/teaspring/article/details/77834360
import ("bytes""compress/gzip"//实现了gzip格式压缩文件的读写"crypto/ecdsa""crypto/elliptic""crypto/md5""crypto/rand""encoding/hex"//实现了16进制字符表示的编解码"errors""fmt""math/big"//实现了大数字的多精度计算"strings"
)
/*
io包提供了对I/O原语的基本接口。本包的基本任务是包装这些原语已有的实现（如os包里的原语），
使之成为共享的公共接口，这些公共接口抽象出了泛用的函数并附加了一些相关的原语的操作
*/
/**通过一个随机key创建公钥和私钥随机key至少为36位
*/func getEcdsaKey() (*ecdsa.PrivateKey, ecdsa.PublicKey, error) {var err errorvar prk *ecdsa.PrivateKeyvar puk ecdsa.PublicKeyvar curve elliptic.Curvecurve = elliptic.P256()//func NewReader(s string) *Readerprk, err = ecdsa.GenerateKey(curve,rand.Reader)if err != nil {return prk, puk, err}//prk:私钥 puk:公钥puk = prk.PublicKeyreturn prk, puk, err}/**对text加密，text必须是一个hash值，例如md5、sha1等使用私钥prk返回加密结果，结果为数字证书r、s的序列化后拼接，然后用hex转换为string
*/
func sign(text []byte, prk *ecdsa.PrivateKey) (string, error) {//r, s, err := ecdsa.Sign(strings.NewReader(randSign), prk, text)r, s, err := ecdsa.Sign(rand.Reader, prk, text)if err != nil {return "", err}rt, err := r.MarshalText()if err != nil {return "", err}st, err := s.MarshalText()if err != nil {return "", err}var b bytes.Buffer//创建并返回一个Writer。写入返回值的数据都会在压缩后写入ww := gzip.NewWriter(&b)//内建函数close关闭信道，该通道必须为双向的或只发送的//defer通常用来释放函数内部变量。defer w.Close()_, err = w.Write([]byte(string(rt) + "+" + string(st)))if err != nil {return "", err}w.Flush()//确保所有的缓存操作已写入底层写入器return hex.EncodeToString(b.Bytes()), nil
}/**证书分解通过hex解码，分割成数字证书r，s
*/
func getSign(signature string) (rint, sint big.Int, err error) {byterun, err := hex.DecodeString(signature)if err != nil {err = errors.New("decrypt error, " + err.Error())return}/*gzip.NewReader(r io.Reader) (*Reader, error)返回一个从r读取并解压数据的*Reader。其实现会缓冲输入流的数据，并可能从r中读取比需要的更多的数据。调用者有责任在读取完毕后调用返回值的Close方法。buffer.NewBuffer(buf []byte) *Buffer { return &Buffer{buf: buf} }使用buf作为初始内容创建并初始化一个Buffer。本函数用于创建一个用于读取已存在数据的buffer；也用于指定用于写入的内部缓冲的大小，此时，buf应为一个具有指定容量但长度为0的切片。buf会被作为返回值的底层缓冲切片。大多数情况下，new(Buffer)（或只是声明一个Buffer类型变量）就足以初始化一个Buffer了。*///Buffer是一个实现了读写方法的可变大小的字节缓冲r, err := gzip.NewReader(bytes.NewBuffer(byterun))if err != nil {err = errors.New("decode error," + err.Error())return}defer r.Close()buf := make([]byte, 1024)//Reader类型满足io.Reader接口，可以从gzip格式压缩文件读取并解压数据。//一般，一个gzip文件可以是多个gzip文件的串联，每一个都有自己的头域。从Reader读取数据会返回串联的每个文件的解压数据，// 但只有第一个文件的头域被记录在Reader的Header字段里。//gzip文件会保存未压缩数据的长度与校验和。当读取到未压缩数据的结尾时，如果数据的长度或者校验和不正确，//Reader会返回ErrCheckSum。因此，调用者应该将Read方法返回的数据视为暂定的，直到他们在数据结尾获得了一个io.EOF。count, err := r.Read(buf)//func (z *Reader) Read(p []byte) (n int, err error)if err != nil {fmt.Println("decode = ", err)err = errors.New("decode read error," + err.Error())return}//Split(s, sep string) []string //sep:步长rs := strings.Split(string(buf[:count]), "+")if len(rs) != 2 {err = errors.New("decode fail")return}//实现了Marshaler接口的类型可以将自身序列化为合法的json描述。//UnmarshalText必须可以解码MarshalText生成的textual格式数据。//本函数可能会对data内容作出修改，所以如果要保持data的数据请事先进行拷贝err = rint.UnmarshalText([]byte(rs[0]))if err != nil {err = errors.New("decrypt rint fail, " + err.Error())return}err = sint.UnmarshalText([]byte(rs[1]))if err != nil {err = errors.New("decrypt sint fail, " + err.Error())return}return}/**校验文本内容是否与签名一致使用公钥校验签名和文本内容
*/
func verify(text []byte, signature string, key ecdsa.PublicKey) (bool, error) {rint, sint, err := getSign(signature)if err != nil {return false, err}result := ecdsa.Verify(&key, text, &rint, &sint)return result, nil
}/**hash加密使用md5加密msg+
*/
//func hashtext(text, salt string) []byte {
func hashtext(text  string) []byte {Md5Inst := md5.New()Md5Inst.Write([]byte(text))//result := Md5Inst.Sum([]byte(salt))return Md5Inst.Sum(nil)
}func main() {//创建公钥和私钥prk, puk, err := getEcdsaKey()if err != nil {fmt.Println(err)}//待加密的明文text := string("少壮不努力,活该你单身2333")//hash取值htext := hashtext(text)//hash值编码输出hex.EncodeToString(htext)//hash值+私钥进行签名result, err := sign(htext, prk)if err != nil {fmt.Println(err)}//签名与hash值进行校验//hash值+密文+公钥tmp, err := verify(htext, result, puk)fmt.Println(tmp)
}