看了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 error
var prk *ecdsa.PrivateKey
var puk ecdsa.PublicKey
var curve elliptic.Curve
curve = elliptic.P256()
//func NewReader(s string) *Reader
prk, err = ecdsa.GenerateKey(curve,rand.Reader)
if err != nil {
return prk, puk, err
}
//prk:私钥 puk:公钥
puk = prk.PublicKey
return 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。写入返回值的数据都会在压缩后写入w
w := 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)
}
