golangsha1解码_golang 椭圆曲线加密使用ecdsa

非对称加密算法有RSA、ECDSA，对极大整数做因数分解的难度决定了RSA算法的可靠性，ECDSA为椭圆曲线加密算法，是基于椭圆方程公式，所以安全性要高于RSA。

这里说下使用ecdsa做签名和校验，并不讲原理；

golang封装的ecdsa目前只有用私钥加密，公钥做校验，没有解密环节；所以目前可以应用于数字签名；

以下为封装：

/**

通过一个随机key创建公钥和私钥

随机key至少为36位

*/

func getEcdsaKey(randKey string) (*ecdsa.PrivateKey, ecdsa.PublicKey, error){

var err error

var prk *ecdsa.PrivateKey

var puk ecdsa.PublicKey

var curve elliptic.Curve

lenth := len(randKey)

if lenth < 224/8 {

err =errors.New("私钥长度太短，至少为36位！")

return prk,puk,err

}

if lenth > 521/8 + 8 {

curve = elliptic.P521()

}else if lenth > 384/8 + 8 {

curve = elliptic.P384()

}else if lenth > 256/8 + 8 {

curve = elliptic.P256()

}else if lenth > 224/8 + 8 {

curve = elliptic.P224()

}

prk, err = ecdsa.GenerateKey(curve,strings.NewReader(randKey))

if err != nil {

return prk, puk, err

}

puk = prk.PublicKey

return prk, puk, err

}

/**

对text加密，text必须是一个hash值，例如md5、sha1等

使用私钥prk

使用随机熵增强加密安全，安全依赖于此熵，randsign

返回加密结果，结果为数字证书r、s的序列化后拼接，然后用hex转换为string

*/

func sign(text []byte,randSign string,prk *ecdsa.PrivateKey) (string, error) {

r, s, err := ecdsa.Sign(strings.NewReader(randSign), 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

w := gzip.NewWriter(&b)

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

}

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)

count, err := r.Read(buf)

if err != nil {

fmt.Println("decode = ",err)

err = errors.New("decode read error," + err.Error())

return

}

rs := strings.Split(string(buf[:count]),"+")

if len(rs) != 2 {

err = errors.New("decode fail")

return

}

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加密

*/

func hashtext(text, salt string) ([]byte) {

Md5Inst := md5.New()

Md5Inst.Write([]byte(text))

result := Md5Inst.Sum([]byte(salt))

return result

}

func main() {

//随机熵，用于加密安全

randSign := "20180619zafes20180619zafes20180619zafessss"//至少36位

//随机key，用于创建公钥和私钥

randKey := "fb0f7279c18d4394594fc9714797c9680335a320"

//创建公钥和私钥

prk, puk, err := getEcdsaKey(randKey)

if err != nil {

fmt.Println(err)

}

//hash加密使用md5用到的salt

salt := "131ilzaw"

//待加密的明文

text := "hlloaefaefaefaefaefaefaefhelloaefaefaefaefaefaefaefhelloaefaefaefaefaefaefaef"

//text1 := "hlloaefaefaefaefaefaefaefhelloaefaefaefaefaefaefaefhelloaefaefaefaefaefaefaef1"

//hash取值

htext := hashtext(text,salt)

//htext1 := hashtext(text1,salt)

//hash值编码输出

fmt.Println(hex.EncodeToString(htext))

//hash值进行签名

result, err := sign(htext,randSign,prk)

if err != nil {

fmt.Println(err)

}

//签名输出

fmt.Println(result)

//签名与hash值进行校验

tmp, err := verify(htext,result,puk)

fmt.Println(tmp)

}

借鉴使用……