Go中使用加密算法的方法

目录

• 椭圆曲线加密算法ecc

哈希算法

 md5

128bit，16字节

如：md5 (“hello world!”) = fc3ff98e8c6a0d3087d515c0473f8677 // 32位16进制数字

func test(t *testing.t) {
	//方法一
	str := "hello world!"
	has := md5.sum([]byte(str))
	md5str1 := fmt.sprintf("%x", has) //将[]byte转成16进制
	t.log(md5str1)

	//方法二
	w := md5.new()
	io.writestring(w, str)
	md5str2 := fmt.sprintf("%x", w.sum(nil))
	t.log(md5str2)
}

sha1

160bit，20字节

如：sha1 (“hello world!”) = 430ce34d020724ed75a196dfc2ad67c77772d169 // 40位16进制数字

func test(t *testing.t) {
	str := "hello world!"

	//产生一个散列值得方式是 sha1.new()，sha1.write(bytes)，然后 sha1.sum([]byte{})。
	h := sha1.new()

	//写入要处理的字节。
	h.write([]byte(str))

	//sha1 值经常以 16 进制输出，例如在 git commit 中。
	t.log(hex.encodetostring(h.sum(nil)))
}

ripemd-160

160bit，20字节

如：ripemd-160 (“hello world!”) = dffd03137b3a333d5754813399a5f437acd694e5 // 40位16进制数字

func test(t *testing.t) {
	str := "hello world!"

	h := ripemd160.new()
	h.write([]byte(str))
	t.log(hex.encodetostring(h.sum(nil)))
}

sha256

256bit，32字节

如：sha256 (“hello world!”) = 7509e5bda0c762d2bac7f90d758b5b2263fa01ccbc542ab5e3df163be08e6ca9 // 64位16进制数字

func test(t *testing.t) {
	str := "hello world!"

	// 第一种调用方法
	sum := sha256.sum256([]byte(str))
	t.logf("%x\n", sum)

	// 第二种调用方法
	h := sha256.new()
	io.writestring(h,str)
	t.log(hex.encodetostring(h.sum(nil)))
}

sha256实现原理
sha-256算法输⼊报⽂的最⼤⻓度不超过2^64 bit，输⼊按512bit分组进⾏处理，产⽣的输出是⼀个256bit的报⽂摘要。
sha256算法包括以下⼏步：

附加填充⽐特

对报⽂进⾏填充，使报⽂⻓度与448 模512 同余（⻓度=448 mod512）,填充的⽐特数范围是1 到512，填充⽐特串的最⾼位为1,其余位为0。就是先在报⽂后⾯加⼀个 1，再加很多个0，直到⻓度满⾜mod512=448。为什么是448，因为448+64=512。第⼆步会加上⼀个64bit的原始报⽂的 ⻓度信息。附加⻓度值

将⽤64bit 表示的初始报⽂（填充前）的位⻓度附加在步骤1的结果后（低位字节优先）初始化缓存

使⽤⼀个256bit 的缓存来存放该散列函数的中间及最终结果。该缓存表示为：

a=0x6a09e667

b=0xbb67ae85

c=0x3c6ef372

d=0xa54ff53a

e=0x510e527f

f=0x9b05688c

g=0x1f83d9ab

h=0x5be0cd19处理512bit（16 个字）报⽂分组序列

该算法使⽤了六种基本逻辑函数，由64 步迭代运算组成。每步都以256bit 缓存abcdefgh 为输⼊，然后更新缓存内容。每步使⽤⼀个32bit 常数值kt 和⼀个32bit wt。

sha512

512bit，64字节

如：sha512 (“hello world!”) = db9b1cd3262dee37756a09b9064973589847caa8e53d31a9d142ea2701b1b28abd97838bb9a27068ba305dc8d04a45a1fcf079de54d607666996b3cc54f6b67c // 128位16进制数字

func test(t *testing.t) {
	str := "hello world!"

	// 第一种调用方法
	sum := sha512.sum512([]byte(str))
	t.logf("%x\n", sum)

	// 第二种调用方法
	h := sha512.new()
	io.writestring(h,str)
	t.log(hex.encodetostring(h.sum(nil)))
}

加密模式

加密一般分为对称加密(symmetric key encryption)和非对称加密(asymmetric key encryption)。

对称加密又分为分组加密和序列密码。

分组密码，也叫块加密(block cyphers)，一次加密明文中的一个块。是将明文按一定的位长分组，明文组经过加密运算得到密文组，密文组经过解密运算（加密运算的逆运算），还原成明文组。

序列密码，也叫流加密(stream cyphers)，一次加密明文中的一个位。是指利用少量的密钥（制乱元素）通过某种复杂的运算（密码算法）产生大量的伪随机位流，用于对明文位流的加密。

解密是指用同样的密钥和密码算法及与加密相同的伪随机位流，用以还原明文位流。

分组加密算法中，有ecb,cbc,cfb,ofb这几种算法模式。

加密模式	解释
ecb	最基本的加密模式，也就是通常理解的加密，相同的明⽂将永远加密成相同的密⽂，⽆初始向量，容易受到密码本重放攻击，⼀般情况下很少⽤
cbc	明⽂被加密前要与前⾯的密⽂进⾏异或运算后再加密，因此只要选择不同的初始向量，相同的密⽂加密后会形成不同的密⽂，这是⽬前应⽤最⼴泛的模式。cbc加密后的密⽂是上下⽂相关的，但明⽂的错误不会传递到后续分组，但如果⼀个分组丢失，后⾯的分组将全部作废(同步错误)
cfb	类似于⾃同步序列密码，分组加密后，按8位分组将密⽂和明⽂进⾏移位异或后得到输出同时反馈回移位寄存器，优点最⼩可以按字节进⾏加解密，也可以是n位的，cfb也是上下⽂相关的，cfb模式下，明⽂的⼀个错误会影响后⾯的密⽂(错误扩散)。
ofb	将分组密码作为同步序列密码运⾏，和cfb相似，不过ofb⽤的是前⼀个n位密⽂输出分组反馈回移位寄存器，ofb没有错误扩散问题

对称加密

最常用的对称加密算法des、3des（tripledes）和aes，常采用的填充⽅式是nopadding（不填充）、zeros填充（0填充）、pkcs5padding填充。

加密算法要求明文需要按一定长度对齐，叫做块大小(blocksize)，比如8字节，那么对于一段任意的数据，加密前需要对最后一个块填充到8 字节，解密后需要删除掉填充的数据。

填充⽅式	解释
zeropadding	数据长度不对齐时使用0填充，否则不填充
pkcs7padding	假设数据长度需要填充n(n>0)个字节才对齐，那么填充n个字节，每个字节都是n;如果数据本身就已经对齐了，则填充一块长度为块大小的数据，每个字节都是块大小
pkcs5padding	pkcs7padding的子集，块大小固定为8字节

由于使用pkcs7padding/pkcs5padding填充时，最后一个字节肯定为填充数据的长度，所以在解密后可以准确删除填充的数据，而使用zeropadding填充时，没办法区分真实数据与填充数据，所以只适合以\0结尾的字符串加解密。

对称加密需要的填充函数

func pkcs5padding(data []byte, blocksize int) []byte {
	padding := blocksize - len(data)%blocksize
	padtext := bytes.repeat([]byte{byte(padding)}, padding)
	return append(data, padtext...)
}

func pkcs5unpadding(data []byte) []byte {
	length := len(data)
	// 去掉最后⼀个字节 unpadding 次
	unpadding := int(data[length-1])
	return data[:(length - unpadding)]
}

func zeropadding(data []byte, blocksize int) []byte {
	padding := blocksize - len(data)%blocksize
	padtext := bytes.repeat([]byte{0}, padding)
	return append(data, padtext...)
}

func zerounpadding(data []byte) []byte {
	return bytes.trimrightfunc(data, func(r rune) bool {
		return r == rune(0)
	})
}

des

//des加密字节数组，返回字节数组
func desencrypt(originalbytes, key []byte) ([]byte, error) {
	block, err := des.newcipher(key)
	if err != nil {
		return nil, err
	}
	originalbytes = pkcs5padding(originalbytes, block.blocksize())
	blockmode := cipher.newcbcencrypter(block, key)
	cipherarr := make([]byte, len(originalbytes))
	blockmode.cryptblocks(cipherarr, originalbytes)
	return cipherarr, nil
}

//des解密字节数组，返回字节数组
func desdecrypt(cipherbytes, key []byte) ([]byte, error) {
	block, err := des.newcipher(key)
	if err != nil {
		return nil, err
	}
	blockmode := cipher.newcbcdecrypter(block, key)
	originaltext := make([]byte, len(cipherbytes))
	blockmode.cryptblocks(originaltext, cipherbytes)
	originaltext = pkcs5unpadding(originaltext)
	return originaltext, nil
}

//des加密⽂本，返回加密后⽂本
func desencryptstring(originaltext string, key []byte) (string, error) {
	cipherarr, err := desencrypt([]byte(originaltext), key)
	if err != nil {
		return "", err
	}
	base64str := base64.stdencoding.encodetostring(cipherarr)
	return base64str, nil
}

//对加密⽂本进⾏des解密，返回解密后明⽂
func desdecryptstring(ciphertext string, key []byte) (string, error) {
	cipherarr, _ := base64.stdencoding.decodestring(ciphertext)
	cipherarr, err := desdecrypt(cipherarr, key)
	if err != nil {
		return "", err
	}
	return string(cipherarr), nil
}

3des

// 3des加密字节数组，返回字节数组
func tripledesencrypt(originalbytes, key []byte) ([]byte, error) {
	block, err := des.newtripledescipher(key)
	if err != nil {
		return nil, err
	}
	originalbytes = pkcs5padding(originalbytes, block.blocksize())
	// originalbytes = zeropadding(originalbytes, block.blocksize())
	blockmode := cipher.newcbcencrypter(block, key[:8])
	cipherarr := make([]byte, len(originalbytes))
	blockmode.cryptblocks(cipherarr, originalbytes)
	return cipherarr, nil
}

// 3des解密字节数组，返回字节数组
func tripledesdecrypt(cipherbytes, key []byte) ([]byte, error) {
	block, err := des.newtripledescipher(key)
	if err != nil {
		return nil, err
	}
	blockmode := cipher.newcbcdecrypter(block, key[:8])
	originalarr := make([]byte, len(cipherbytes))
	blockmode.cryptblocks(originalarr, cipherbytes)
	originalarr = pkcs5unpadding(originalarr)
	// origdata = zerounpadding(origdata)
	return originalarr, nil
}

// 3des加密字符串，返回base64处理后字符串
func tripledesencrypt2str(originaltext string, key []byte) (string, error) {
	block, err := des.newtripledescipher(key)
	if err != nil {
		return "", err
	}
	originaldata := pkcs5padding([]byte(originaltext), block.blocksize())
	// originaldata = zeropadding(originaldata, block.blocksize())
	blockmode := cipher.newcbcencrypter(block, key[:8])
	cipherarr := make([]byte, len(originaldata))
	blockmode.cryptblocks(cipherarr, originaldata)
	ciphertext := base64.stdencoding.encodetostring(cipherarr)
	return ciphertext, nil
}

// 3des解密base64处理后的加密字符串，返回明⽂字符串
func tripledesdecrypt2str(ciphertext string, key []byte) (string, error) {
	cipherarr, _ := base64.stdencoding.decodestring(ciphertext)
	block, err := des.newtripledescipher(key)
	if err != nil {
		return "", err
	}
	blockmode := cipher.newcbcdecrypter(block, key[:8])
	originalarr := make([]byte, len(cipherarr))
	blockmode.cryptblocks(originalarr, cipherarr)
	originalarr = pkcs5unpadding(originalarr)
	// origdata = zerounpadding(origdata)
	return string(originalarr), nil
}

aes

//aes加密字节数组，返回字节数组
func aesencrypt(originalbytes, key []byte) ([]byte, error) {
	block, err := aes.newcipher(key)
	if err != nil {
		return nil, err
	}
	blocksize := block.blocksize()
	originalbytes = pkcs5padding(originalbytes, blocksize)
	// originalbytes = zeropadding(originalbytes, block.blocksize())
	blockmode := cipher.newcbcencrypter(block, key[:blocksize])
	cipherbytes := make([]byte, len(originalbytes))
	// 根据cryptblocks⽅法的说明，如下⽅式初始化crypted也可以
	// crypted := originalbytes
	blockmode.cryptblocks(cipherbytes, originalbytes)
	return cipherbytes, nil
}

//aes解密字节数组，返回字节数组
func aesdecrypt(cipherbytes, key []byte) ([]byte, error) {
	block, err := aes.newcipher(key)
	if err != nil {
		return nil, err
	}
	blocksize := block.blocksize()
	blockmode := cipher.newcbcdecrypter(block, key[:blocksize])
	originalbytes := make([]byte, len(cipherbytes))
	// origdata := cipherbytes
	blockmode.cryptblocks(originalbytes, cipherbytes)
	originalbytes = pkcs5unpadding(originalbytes)
	// origdata = zerounpadding(origdata)
	return originalbytes, nil
}

//aes加密⽂本，返回对加密后字节数组进⾏base64处理后字符串
func aesencryptstring(originaltext string, key []byte) (string, error) {
	cipherbytes, err := aesencrypt([]byte(originaltext), key)
	if err != nil {
		return "", err
	}
	base64str := base64.stdencoding.encodetostring(cipherbytes)
	return base64str, nil
}

//aes解密⽂本，对base64处理后的加密⽂本进⾏aes解密，返回解密后明⽂
func aesdecryptstring(ciphertext string, key []byte) (string, error) {
	cipherbytes, _ := base64.stdencoding.decodestring(ciphertext)
	cipherbytes, err := aesdecrypt(cipherbytes, key)
	if err != nil {
		return "", err
	}
	return string(cipherbytes), nil
}

⾮对称加密

rsa算法也是一个块加密算法（ block cipher algorithm），总是在一个固定长度的块上进行操作。但跟aes等不同的是，block length是跟key length有关的。

每次rsa加密的明文的长度是受rsa填充模式限制的，但是rsa每次加密的块长度就是key length。

填充⽅式	密文长度
pkcs1padding	必须 比 rsa 秘钥模长(modulus) 短至少11个字节, 也就是rsa_size(rsa) – 11
oaeppadding	rsa_size(rsa) – 41
nopadding	可以和rsa钥模长一样长，如果输入的明文过长，必须切割，　然后填充

在不同的padding模式下，使用相同长度的密钥可以加密的数据最大长度不同在不同密钥长度下，使用相同的padding模式可以加密的数据最大长度也不同

因此，脱离了密钥长度而讨论padding模式可以加密的最大长度是不严谨的。常用的密钥长度有1024bits，2048bits等，理论上1024bits的密钥可以加密的数据最大长度为1024bits（即1024/8 = 128bytes）。2048bits的密钥可以加密的数据最大长度为2048bits(2048/8 = 256bytes)，但是rsa在实际应用中不可能使用这种“教科书式的rsa”系统。实际应用中rsa经常与填充技术（padding）一起使用，可以增加rsa的安全性。

pkcs1

// 加密字节数组，返回字节数组
func rsaencrypt(publickey, origdata []byte) ([]byte, error) {
	block, _ := pem.decode(publickey)
	if block == nil {
		return nil, errors.new("public key error")
	}
	pubinterface, err := x509.parsepkixpublickey(block.bytes)
	if err != nil {
		return nil, err
	}
	pub := pubinterface.(*rsa.publickey)
	return rsa.encryptpkcs1v15(rand.reader, pub, origdata)
}

// 解密字节数组，返回字节数组
func rsadecrypt(privatekey, ciphertext []byte) ([]byte, error) {
	block, _ := pem.decode(privatekey)
	if block == nil {
		return nil, errors.new("private key error!")
	}
	priv, err := x509.parsepkcs1privatekey(block.bytes)
	if err != nil {
		return nil, err
	}
	return rsa.decryptpkcs1v15(rand.reader, priv, ciphertext)
}

// 加密字符串，返回base64处理的字符串
func rsaencryptstring(publickey []byte, origdata string) (string, error) {
	block, _ := pem.decode(publickey)
	if block == nil {
		return "", errors.new("public key error")
	}
	pubinterface, err := x509.parsepkixpublickey(block.bytes)
	if err != nil {
		return "", err
	}
	pub := pubinterface.(*rsa.publickey)
	cipherarr, err := rsa.encryptpkcs1v15(rand.reader, pub, []byte(origdata))
	if err != nil {
		return "", err
	} else {
		return base64.stdencoding.encodetostring(cipherarr), nil
	}
}

// 解密经过base64处理的加密字符串，返回加密前的明⽂
func rsadecryptstring(privatekey []byte, ciphertext string) (string, error) {
	block, _ := pem.decode(privatekey)
	if block == nil {
		return "", errors.new("private key error!")
	}
	priv, err := x509.parsepkcs1privatekey(block.bytes)
	if err != nil {
		return "", err
	}
	cipherarr, _ := base64.stdencoding.decodestring(ciphertext)
	originalarr, err := rsa.decryptpkcs1v15(rand.reader, priv, cipherarr)
	if err != nil {
		return "", err
	} else {
		return string(originalarr), nil
	}
}

oaep

// 加密
func encryptoaep(publickey []byte, text string) (string, error) {
	block, _ := pem.decode(publickey)
	if block == nil {
		return "", errors.new("public key error")
	}

	pubinterface, err := x509.parsepkixpublickey(block.bytes)
	if err != nil {
		return "", err
	}

	pub := pubinterface.(*rsa.publickey)

	secretmessage := []byte(text)
	rng := rand.reader
	cipherdata, err := rsa.encryptoaep(sha1.new(), rng, pub, secretmessage, nil)
	if err != nil {
		return "", err
	}
	ciphertext := base64.stdencoding.encodetostring(cipherdata)
	return ciphertext, nil
}

// 解密
func decryptoaep(privatekey []byte, ciphertext string) (string, error) {
	block, _ := pem.decode(privatekey)
	if block == nil {
		return "", errors.new("private key error!")
	}

	priv, err := x509.parsepkcs1privatekey(block.bytes)
	if err != nil {
		return "", err
	}

	cipherdata, _ := base64.stdencoding.decodestring(ciphertext)
	rng := rand.reader
	plaintext, err := rsa.decryptoaep(sha1.new(), rng, priv, cipherdata, nil)
	if err != nil {
		return "", err
	}
	return string(plaintext), nil
}

椭圆曲线加密算法ecc

椭圆曲线密码学（elliptic curve cryptography，缩写为 ecc），是基于椭圆曲线数学理论实现的⼀种⾮对称加密算法。

ecc与rsa算法的优势对⽐

椭圆曲线公钥系统是代替rsa的强有⼒的竞争者。

与经典的rsa、dsa等公钥密码体制相⽐，椭圆密码体制有以下优点：

（1）安全性能更⾼（ecc可以使⽤更短的密钥）：

160位ecc加密算法的安全强度相当于1024位rsa加密；

210位ecc加密算法的安全强度相当于2048位rsa加密。

（2）处理速度快：计算量⼩，处理速度快 在私钥的处理速度上（解密和签名），ecc远 ⽐rsa、dsa快得多。

（3）存储空间占⽤⼩： ecc的密钥尺⼨和系统参数与rsa、dsa相⽐要⼩得多， 所以占⽤的存储空间⼩得多。

（4）带宽要求低使得ecc具有⼴泛的应⽤前景。ecc的这些特点使它必将取代rsa，成为通⽤的公钥加密算法。

//生成ecc椭圆曲线密钥对
func generateecckey() (*ecdsa.publickey, *ecdsa.privatekey, error) {
	privatekey, err := ecdsa.generatekey(elliptic.p521(), rand.reader)
	if err != nil {
		return nil, nil, err
	}

	publickey := &privatekey.publickey
	return publickey, privatekey, nil
}

//对消息的散列值生成数字签名
func signecc(msg []byte) ([]byte, []byte) {
	//取得私钥
	_, privatekey, err := generateecckey()
	if err != nil {
		panic(err)
	}

	//计算哈希值
	hash := sha256.new()

	//填入数据
	hash.write(msg)
	b := hash.sum(nil)

	//对哈希值生成数字签名
	r, s, err := ecdsa.sign(rand.reader, privatekey, b)
	if err != nil {
		panic(err)
	}

	rtext, _ := r.marshaltext()
	stext, _ := s.marshaltext()
	return rtext, stext
}

//验证数字签名
func verifysignecc(msg []byte, rtext, stext []byte) bool {
	//取得公钥
	publickey, _, err := generateecckey()
	if err != nil {
		panic(err)
	}

	//计算哈希值
	hash := sha256.new()
	hash.write(msg)
	b := hash.sum(nil)

	//验证数字签名
	var r, s big.int
	if err := r.unmarshaltext(rtext); err != nil {
		panic(err)
	}
	if err := s.unmarshaltext(stext); err != nil {
		panic(err)
	}

	verify := ecdsa.verify(publickey, b, &r, &s)
	return verify
}

//测试
func test(t *testing.t) {
	//模拟发送者
	//要发送的消息
	msg := []byte("hello world")
	//生成数字签名
	rtext, stext := signecc(msg)

	//模拟接受者
	//接受到的消息
	acceptmsg := []byte("hello world")
	//接收到的签名
	acceptrtext := rtext
	acceptstext := stext
	//验证签名
	verifysignecc := verifysignecc(acceptmsg, acceptrtext, acceptstext)
	fmt.println("验证结果：", verifysignecc)
}

数字签名

数字签名的概念

1、签名不可伪造性；
2、签名不可抵赖的；
3、签名可信性，签名的识别和应⽤相对容易，任何⼈都可以验证签名的有效
性；
4、签名是不可复制的，签名与原⽂是不可分割的整体；
5、签名消息不可篡改，因为任意⽐特数据被篡改，其签名便被随之改变，那么
任何⼈可以验证⽽拒绝接受此签名。

椭圆曲线数字签名算法ecdsa

//⽣成私钥和公钥，⽣成的私钥为结构体ecdsa.privatekey的指针
func newkeypair() (ecdsa.privatekey, []byte) {
	//⽣成secp256椭圆曲线
	curve := elliptic.p256()
	//产⽣的是⼀个结构体指针，结构体类型为ecdsa.privatekey
	private, err := ecdsa.generatekey(curve, rand.reader)
	if err != nil {
		log.panic(err)
	}
	fmt.printf("私钥：%x\n", private)
	fmt.printf("私钥x：%x\n", private.x.bytes())
	fmt.printf("私钥y：%x\n", private.y.bytes())
	fmt.printf("私钥d：%x\n", private.d.bytes())
	//x坐标与y坐标拼接在⼀起，⽣成公钥
	pubkey := append(private.x.bytes(), private.y.bytes()...)
	//打印公钥，公钥⽤16进制打印出来⻓度为128，包含了x轴坐标与y轴坐标。
	fmt.printf("公钥：%x \n", pubkey)
	return *private, pubkey
}

//⽣成签名的der格式
func makesignaturederstring(r, s string) string {
	// 获取r和s的⻓度
	lensigr := len(r) / 2
	lensigs := len(s) / 2
	// 计算der序列的总⻓度
	lensequence := lensigr + lensigs + 4
	// 将10进制⻓度转16进制字符串
	strlensigr := decimaltohex(int64(lensigr))
	strlensigs := decimaltohex(int64(lensigs))
	strlensequence := decimaltohex(int64(lensequence))
	// 拼凑der编码
	derstring := "30" + strlensequence
	derstring = derstring + "02" + strlensigr + r
	derstring = derstring + "02" + strlensigs + s
	derstring = derstring + "01"
	return derstring
}

func decimaltohex(n int64) string {
	if n < 0 {
		log.println("decimal to hexadecimal error: the argument must be greater than zero.")
		return ""
	}
	if n == 0 {
		return "0"
	}

	hex := map[int64]int64{10: 65, 11: 66, 12: 67, 13: 68, 14: 69, 15: 70}
	s := ""
	for q := n; q > 0; q = q / 16 {
		m := q % 16
		if m > 9 && m < 16 {
			m = hex[m]
			s = fmt.sprintf("%v%v", string(m), s)
			continue
		}
		s = fmt.sprintf("%v%v", m, s)
	}
	return s
}

//验证签名1
func verifysig(pubkey, message []byte, r, s *big.int) bool {
	curve := elliptic.p256()
	//公钥的⻓度
	keylen := len(pubkey)
	//前⼀半为x轴坐标，后⼀半为y轴坐标
	x := big.int{}
	y := big.int{}
	x.setbytes(pubkey[:(keylen / 2)])
	y.setbytes(pubkey[(keylen / 2):])
	rawpubkey := ecdsa.publickey{curve, &x, &y}
	//根据交易哈希、公钥、数字签名验证成功。ecdsa.verify func verify(pub *publickey, hash[] byte, r * big.int, s * big.int) bool
	res := ecdsa.verify(&rawpubkey, message, r, s)
	return res
}

//验证签名2
func verifysignature(pubkey, message []byte, r, s string) bool {
	curve := elliptic.p256()
	//公钥的⻓度
	keylen := len(pubkey)
	//前⼀半为x轴坐标，后⼀半为y轴坐标
	x := big.int{}
	y := big.int{}
	x.setbytes(pubkey[:(keylen / 2)])
	y.setbytes(pubkey[(keylen / 2):])
	rawpubkey := ecdsa.publickey{curve, &x, &y}
	//根据交易哈希、公钥、数字签名验证成功。ecdsa.verify func verify(pub *publickey, hash[] byte, r * big.int, s * big.int) bool
	rint := big.int{}
	sint := big.int{}
	rbyte, _ := hex.decodestring(r)
	sbyte, _ := hex.decodestring(s)
	rint.setbytes(rbyte)
	sint.setbytes(sbyte)
	//fmt.println("------", rint.setbytes(rbyte))
	//fmt.println("------", sint.setbytes(sbyte))
	res := ecdsa.verify(&rawpubkey, message, &rint, &sint)
	return res
}

//验证过程
func test(t *testing.t) {
	//1、⽣成签名
	fmt.println("1、⽣成签名-------------------------------")
	//调⽤函数⽣成私钥与公钥
	privkey, pubkey := newkeypair()
	//信息的哈希
	msg := sha256.sum256([]byte("hello world"))
	//根据私钥和信息的哈希进⾏数字签名，产⽣r和s
	r, s, _ := ecdsa.sign(rand.reader, &privkey, msg[:])
	//⽣成r、s字符串
	fmt.println("-------------------------------")
	strsigr := fmt.sprintf("%x", r)
	strsigs := fmt.sprintf("%x", s)
	fmt.println("r、s的10进制分别为：", r, s)
	fmt.println("r、s的16进制分别为：", strsigr, strsigs)
	//r和s拼接在⼀起，形成数字签名的der格式
	signatureder := makesignaturederstring(strsigr, strsigs)
	//打印数字签名的16进制显示
	fmt.println("数字签名der格式为：", signatureder)
	fmt.println()
	//2、签名验证过程
	fmt.println("2、签名验证过程-------------------------------")
	res := verifysig(pubkey, msg[:], r, s)
	fmt.println("签名验证结果：", res)
	res = verifysignature(pubkey, msg[:], strsigr, strsigs)
	fmt.println("签名验证结果：", res)
}

字符编码/解码

base64

base64就是⼀种基于64个可打印字符来表示⼆进制数据的⽅法。base64使⽤了26个⼩写字⺟、26个⼤写字⺟、10个数字以及两个符号（例如“+”和“/”），⽤于在电⼦邮件这样的基于⽂本的媒介中传输⼆进制数据。

base64字符集：
abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz0123456789+/

base64的步骤

将每个字符转成ascii编码（10进制）将10进制编码转成2进制编码将2进制编码按照6位⼀组进⾏平分将6位⼀组的2进制数⾼位补零，然后转成10进制数将10进制数作为索引，从base64编码表中查找字符每3个字符的⽂本将编码为4个字符⻓度（3
8=46）

a. 若⽂本为3个字符，则正好编码为4个字符⻓度；

b. 若⽂本为2个字符，则编码为3个字符，由于不⾜4个字符，则在尾部⽤⼀个“=”补⻬；

c. 若⽂本为1个字符，则编码为2个字符，由于不⾜4个字符，则在尾部⽤两个“=”补⻬。

巨人的肩膀

从他人的工作中汲取经验来避免自己的错误重复，正如我们是站在巨人的肩膀上才能做出更好的成绩。

https://github.com/rubyhan1314/golang-100-days
https://blog.csdn.net/luckydog612/article/details/80547758
https://www.cnblogs.com/yanzi-meng/p/9640578.html
https://www.cnblogs.com/starwolf/p/3365834.html
https://blog.csdn.net/u013073067/article/details/87086562
https://www.cnblogs.com/terry-wu/p/10314315.html
http://blog.studygolang.com/2013/01/go%e5%8a%a0%e5%af%86%e8%a7%a3%e5%af%86%e4%b9%8bdes/
https://blog.csdn.net/kikajack/article/details/78329567

到此这篇关于go中使用加密算法的方法的文章就介绍到这了,更多相关go 加密算法内容请搜索www.887551.com以前的文章或继续浏览下面的相关文章希望大家以后多多支持www.887551.com！