【Go基础】加密算法和数据结构

最新推荐文章于 2024-05-17 07:32:05 发布
最新推荐文章于 2024-05-17 07:32:05 发布
阅读量2k 收藏 2
点赞数
分类专栏： Go 文章标签： golang 数据结构 区块链
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52665939/article/details/128763478
版权

文章目录

一、加密算法

1. 对称加密

在这里插入图片描述

加密过程的每一步都是可逆的
加密和解密用的是同一组密钥
异或是最简单的对称加密算法

// XOR 异或运算，要求plain和key的长度相同
func XOR(plain string, key []byte) string {
	bPlain := []byte(plain)
	bCipher := make([]byte, len(key))
	for i, k := range key {
		bCipher[i] = k ^ bPlain[i]
	}
	cipher := string(bCipher)
	return cipher
}

DES（Data Encryption Standard）数据加密标准，是目前最为流行的加密算法之一
对原始数据（明文）进行分组，每组64位，最后一组不足64位时按一定规则填充，每一组上单独施加DES算法
DES子密钥生成
初始密钥64位，实际有效位56位，每隔7位有一个校验位，根据初始密钥生成16个48位的子密钥
在这里插入图片描述
在这里插入图片描述

N取值从1到16，N和x有固定的映射表

DES加密过程
在这里插入图片描述
在这里插入图片描述

L1, R1 = f(L0, R0, K1)，依此循环，得到L16和R16
S盒替换，输入48位，输出32位，各分为8组，输入每组6位，输出每组4位，分别在每组上施加S盒替换，一共8个S盒

在这里插入图片描述

CBC加密过程
在这里插入图片描述

分组模式，CBC（Cipher Block Chaining ）密文分组链接模式，将当前明文分组与前一个密文分组进行异或运算，然后再进行加密
其他分组模式还有ECB, CTR, CFR, OFB

func DesEncryptCBC(text string, key []byte) (string, error) {
	src := []byte(text)
	block, err := des.NewCipher(key) // 用des创建一个加密器cipher
	if err != nil {
		return "", err
	}
	blockSize := block.BlockSize() // 分组的大小，blockSize=8
	src = common.ZeroPadding(src, blockSize) // 填充

	out := make([]byte, len(src)) // 密文和明文的长度一致
	encrypter := cipher.NewCBCEncrypter(block, key) // CBC分组模式加密
	encrypter.CryptBlocks(out, src)
	return hex.EncodeToString(out), nil
}

func DesDecryptCBC(text string, key []byte) (string, error) {
	src, err := hex.DecodeString(text) // 转成[]byte
	if err != nil {
		return "", err
	}
	block, err := des.NewCipher(key)
	if err != nil {
		return "", err
	}
 
	out := make([]byte, len(src)) // 密文和明文的长度一致
	encrypter := cipher.NewCBCDecrypter(block, key) // CBC分组模式解密
	encrypter.CryptBlocks(out, src)
	out = common.ZeroUnPadding(out) // 反填充
	return string(out), nil
}

AES（Advanced Encryption Standard）高级加密标准，旨在取代DES

2. 非对称加密

  • 使用公钥加密，使用私钥解密
  • 公钥和私钥不同
  • 公钥可以公布给所有人
  • 私钥只有自己保存
  • 相比于对称加密，运算速度非常慢

在这里插入图片描述

对称加密和非对称加密结合使用的案例：
小明要给小红传输机密文件，他俩先交换各自的公钥，然后：

  • 小明生成一个随机的AES口令，然后用小红的公钥通过RSA加密这个口令，并发给小红
  • 小红用自己的RSA私钥解密得到AES口令
  • 双方使用这个共享的AES口令用AES加密通信

在这里插入图片描述

RSA是三个发明人名字的缩写：Ron Rivest，Adi Shamir，Leonard Adleman，密钥越长，越难破解，目前768位的密钥还无法破解（至少没人公开宣布），因此可以认为1024位的RSA密钥基本安全，2048位的密钥极其安全，RSA的算法原理主要用到了数论
RSA加密过程：

  • 随机选择两个不相等的质数p和q：p=61, q=53
  • 计算p和q的乘积n：n=3233
  • 计算n的欧拉函数φ(n) = (p-1)(q-1)： φ(n) =3120
  • 随机选择一个整数e，使得1< e < φ(n)，且e与φ(n) 互质：e=17
  • 计算e对于φ(n)的模反元素d，即求解e*d+ φ(n)*y=1：d=2753, y=-15
  • 将n和e封装成公钥，n和d封装成私钥：公钥=(3233，17)，公钥=(3233，2753)
// RSA加密
func RsaEncrypt(origData []byte) ([]byte, error) {
	// 解密pem格式的公钥
	block, _ := pem.Decode(publicKey)
	if block == nil {
		return nil, errors.New("public key error")
	}
	// 解析公钥
	pubInterface, err := x509.ParsePKIXPublicKey(block.Bytes) // 目前的数字证书一般都是基于ITU（国际电信联盟）制定的X.509标准
	if err != nil {
		return nil, err
	}
	// 类型断言
	pub := pubInterface.(*rsa.PublicKey)
	// 加密
	return rsa.EncryptPKCS1v15(rand.Reader, pub, origData)
}

// RSA解密
func RsaDecrypt(ciphertext []byte) ([]byte, error) {
	// 解密
	block, _ := pem.Decode(privateKey)
	if block == nil {
		return nil, errors.New("private key error!")
	}
	// 解析PKCS1格式的私钥
	priv, err := x509.ParsePKCS1PrivateKey(block.Bytes)
	if err != nil {
		return nil, err
	}
	// 解密
	return rsa.DecryptPKCS1v15(rand.Reader, priv, ciphertext)
}

ECC（Elliptic Curve Cryptography）椭圆曲线加密算法，相比RSA，ECC可以使用更短的密钥，来实现与RSA相当或更高的安全
定义了椭圆曲线上的加法和二倍运算，椭圆曲线依赖的数学难题是：k为正整数，P是椭圆曲线上的点（称为基点）, k*P=Q , 已知Q和P，很难计算出k

func genPrivateKey() (*ecies.PrivateKey, error) {
	pubkeyCurve := elliptic.P256() // 初始化椭圆曲线
	// 随机挑选基点,生成私钥
	p, err := ecdsa.GenerateKey(pubkeyCurve, rand.Reader) // 用golang标准库生成公私钥对
	if err != nil {
		return nil, err
	} else {
		return ecies.ImportECDSA(p), nil // 转换成以太坊的公私钥对
	}
}

// ECCEncrypt 椭圆曲线加密
func ECCEncrypt(plain string, pubKey *ecies.PublicKey) ([]byte, error) {
	src := []byte(plain)
	return ecies.Encrypt(rand.Reader, pubKey, src, nil, nil)
}

// ECCDecrypt 椭圆曲线解密
func ECCDecrypt(cipher []byte, prvKey *ecies.PrivateKey) (string, error) {
	if src, err := prvKey.Decrypt(cipher, nil, nil); err != nil {
		return "", err
	} else {
		return string(src), nil
	}
}

3. 哈希算法

哈希函数的基本特征：

  • 输入可以是任意长度
  • 输出是固定长度
  • 根据输入很容易计算出输出
  • 根据输出很难计算出输入（几乎不可能）
  • 两个不同的输入几乎不可能得到相同的输出

SHA（Secure Hash Algorithm） 安全散列算法，是一系列密码散列函数，有多个不同安全等级的版本：SHA-1,SHA-224,SHA-256,SHA-384,SHA-512，其作用是防伪装，防窜扰，保证信息的合法性和完整性
sha-1算法大致过程：

  • 填充，使得数据长度对512求余的结果为448
  • 在信息摘要后面附加64bit，表示原始信息摘要的长度
  • 初始化h0到h4，每个h都是32位
  • h0到h4历经80轮复杂的变换
  • 把h0到h4拼接起来，构成160位，返回
func Sha1(data string) string {
	sha1 := sha1.New()
	sha1.Write([]byte(data))
	return hex.EncodeToString(sha1.Sum(nil))
}

MD5（Message-Digest Algorithm 5）信息-摘要算法5，算法流程跟SHA-1大体相似，MD5的输出是128位，比SHA-1短了32位，MD5相对易受密码分析的攻击，但运算速度比SHA-1快

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

哈希函数的应用场景

  • 用户密码的存储
  • 文件上传/下载完整性校验
  • mysql大字段的快速对比

数字签名

在这里插入图片描述
比特币中验证交易记录的真实性用的就是数字签名，先hash再用私钥加密的原因是：非对称加密计算量比较大，先hash可以把原始数据转一条很短的信息，提高计算效率

二、数据结构与算法

1. 链表

在这里插入图片描述

链表的一个应用案例，LRU（Least Recently Used，最近最少使用）缓存淘汰的总体思路：缓存的key放到链表中，头部的元素表示最近刚使用

  • 如果命中缓存，从链表中找到对应的key，移到链表头部
  • 如果没命中缓存：
    • 如果缓存容量没超，放入缓存，并把key放到链表头部
    • 如果超出缓存容量，删除链表尾部元素，再把key放到链表头部

在这里插入图片描述

ring的应用：基于滑动窗口的统计，比如最近100次接口调用的平均耗时、最近10笔订单的平均值、最近30个交易日股票的最高点；ring的容量即为滑动窗口的大小，把待观察变量按时间顺序不停地写入ring即可

package main

import (
	"container/ring"
	"fmt"
)

func TraverseRing(ring *ring.Ring) {
	// 通过Do()来遍历ring，内部实际上调用了Next()而非Prev()
	ring.Do(func(i interface{}) {
		fmt.Printf("%v ", i)
	})
	fmt.Println()
}

func main() {
	ring := ring.New(5) // 必须指定长度，各元素被初始化为nil
	ring2 := ring.Prev()
	for i := 0; i < 3; i++ {
		ring.Value = i
		ring = ring.Next()
	}
	for i := 0; i < 3; i++ {
		ring2.Value = i
		ring2 = ring2.Prev()
	}
	TraverseRing(ring)
	TraverseRing(ring2) // ring和ring2当前所在的指针位置不同，所以遍历出来的顺序也不同
}

2. 栈

栈是一种先进后出的数据结构，push把元素压入栈底，pop弹出栈顶的元素，编程语言的编译系统也用到了栈的思想

在这里插入图片描述

go自带的List已经包含了栈的功能，这里实现一个线程安全的栈

type (
	node struct {
		value interface{}
		prev  *node
	}
	MyStack struct {
		top    *node
		length int
		lock   *sync.RWMutex
	}
)

func NewMyStack() *MyStack {
	return &MyStack{nil, 0, &sync.RWMutex{}}
}

func (stack *MyStack) Push(value interface{}) {
	stack.lock.Lock()
	defer stack.lock.Unlock()
	n := &node{value, stack.top}
	stack.top = n
	stack.length++
}

func (stack *MyStack) Pop() interface{} {
	stack.lock.Lock()
	defer stack.lock.Unlock()
	if stack.length == 0 {
		return nil
	}
	n := stack.top
	stack.top = n.prev
	stack.length--
	return n.value
}

func (stack *MyStack) Peak() interface{} {
	stack.lock.RLock()
	defer stack.lock.RUnlock()
	if stack.length == 0 {
		return nil
	}
	return stack.top.value
}

func (stack *MyStack) Len() int {
	return stack.length
}

func (stack *MyStack) Empty() bool {
	return stack.Len() == 0
}

3. 堆

堆是一棵二叉树，大根堆即任意节点的值都大于等于其子节点，反之为小根堆
用数组来表示堆，下标为 i 的结点的父结点下标为(i-1)/2，其左右子结点分别为 (2i + 1)、(2i + 2)

在这里插入图片描述

构建堆

在这里插入图片描述

package main

import "fmt"

// AdjustTraingle 如果只是修改slice里的元素，不需要传slice的指针；如果要往slice里append或让slice指向新的子切片，则需要传slice指针
func AdjustTraingle(arr []int, parent int) {
	left := 2 * parent + 1
	if left >= len(arr) {
		return
	}

	right := 2 * parent + 2
	minIndex := parent
	minValue := arr[minIndex]
	if arr[left] < minValue {
		minValue = arr[left]
		minIndex = left
	}
	if right < len(arr) {
		if arr[right] < minValue {
			minValue = arr[right]
			minIndex = right
		}
	}
	if minIndex != parent {
		arr[minIndex], arr[parent] = arr[parent], arr[minIndex]
		// 递归，每当有元素调整下来时，要对以它为父节点的三角形区域进行调整
		AdjustTraingle(arr, minIndex)
	}
}

func ReverseAdjust(arr []int) {
	n := len(arr)
	if n <= 1 {
		return
	}
	lastIndex := n / 2 * 2
	fmt.Println(lastIndex)
	// 逆序检查每一个三角形区域
	for i := lastIndex; i > 0; i -= 2 {
		right := i
		parent := (right - 1) / 2
		fmt.Println(parent)
		AdjustTraingle(arr, parent)
	}
}

func buildHeap() {
	arr := []int{62, 40, 20, 30, 15, 10, 49}
	ReverseAdjust(arr)
	fmt.Println(arr)
}

每当有元素调整下来时，要对以它为父节点的三角形区域进行调整

插入元素

在这里插入图片描述

删除堆顶

在这里插入图片描述

下面讲几个堆的应用
堆排序：

  • 构建堆O(N)
  • 不断地删除堆顶O(NlogN)

求集合中最大的K个元素：

  • 用集合的前K个元素构建小根堆
  • 逐一遍历集合的其他元素，如果比堆顶小直接丢弃；否则替换掉堆顶，然后向下调整堆

把超时的元素从缓存中删除：

  • 按key的到期时间把key插入小根堆中
  • 周期扫描堆顶元素，如果它的到期时间早于当前时刻，则从堆和缓存中删除，然后向下调整堆

Golang中的container/heap实现了小根堆，但需要自己定义一个类，实现以下接口：

  • Len() int
  • Less(i, j int) bool
  • Swap(i, j int)
  • Push(x interface{})
  • Pop() x interface{}
type Item struct {
	Value    string
	priority int // 优先级，数字越大，优先级越高
}

type PriorityQueue []*Item

func (pq PriorityQueue) Len() int {
	return len(pq)
}

func (pq PriorityQueue) Less(i, j int) bool {
	// Golang默认提供的是小根堆，而优先队列是大根堆，所以这里要反着定义Less
	return pq[i].priority > pq[j].priority
}

func (pq PriorityQueue) Swap(i, j int) {
	pq[i], pq[j] = pq[j], pq[i]
}

// 往slice里append，需要传slice指针
func (pq *PriorityQueue) Push(x interface{}) {
	item := x.(*Item)
	*pq = append(*pq, item)
}

// 让slice指向新的子切片，需要传slice指针
func (pq *PriorityQueue) Pop() interface{} {
	old := *pq
	n := len(old)
	item := old[n-1] // 数组最后一个元素
	*pq = old[0 : n-1] // 去掉最一个元素
	return item
}

4. Trie树

Trie树又叫字典权
现有term集合：{分散，分散精力，分散投资，分布式，工程，工程师}，把它们放到Trie树里如下图：

在这里插入图片描述

Trie树的根节点是总入口，不存储字符；对于英文，第个节点有26个子节点，子节点可以存到数组里；中文由于汉字很多，用数组存子节点太浪费内存，可以用map存子节点；从根节点到叶节点的完整路径是一个term，从根节点到某个中间节点也可能是一个term，即一个term可能是另一个term的前缀；上图中红圈表示从根节点到本节点是一个完整的term

package main

import "fmt"

type TrieNode struct {
	Word     rune // 当前节点存储的字符。byte只能表示英文字符，rune可以表示任意字符
	Children map[rune]*TrieNode // 孩子节点，用一个map存储
	Term     string
}

type TrieTree struct {
	root *TrieNode
}

// add 把words[beginIndex:]插入到Trie树中
func (node *TrieNode) add(words []rune, term string, beginIndex int) {
	// words已经遍历完了
	if beginIndex >= len(words) {
		node.Term = term
		return
	}

	if node.Children == nil {
		node.Children = make(map[rune]*TrieNode)
	}

	word := words[beginIndex] // 把这个word放到node的子节点中
	if child, exists := node.Children[word]; !exists {
		newNode := &TrieNode{Word: word}
		node.Children[word] = newNode
		newNode.add(words, term, beginIndex+1) // 递归
	} else {
		child.add(words, term, beginIndex+1) // 递归
	}
}

// walk words[0]就是当前节点上存储的字符，按照words的指引顺着树往下走，最终返回words最后一个字符对应的节点
func (node *TrieNode) walk(words []rune, beginIndex int) *TrieNode {
	if beginIndex == len(words)-1 {
		return node
	}
	beginIndex += 1
	word := words[beginIndex]
	if child, exists := node.Children[word]; exists {
		return child.walk(words, beginIndex)
	} else {
		return nil
	}
}

// traverseTerms 遍历一个node下面所有的term，注意要传数组的指针，才能真正修改这个数组
func (node *TrieNode) traverseTerms(terms *[]string) {
	if len(node.Term) > 0 {
		*terms = append(*terms, node.Term)
	}
	for _, child := range node.Children {
		child.traverseTerms(terms)
	}
}

func (tree *TrieTree) AddTerm(term string) {
	if len(term) <= 1 {
		return
	}
	words := []rune(term)

	if tree.root == nil {
		tree.root = new(TrieNode)
	}

	tree.root.add(words, term, 0)
}

func (tree *TrieTree) Retrieve(prefix string) []string {
	if tree.root == nil || len(tree.root.Children) == 0 {
		return nil
	}
	words := []rune(prefix)
	firstWord := words[0]
	if child, exists := tree.root.Children[firstWord]; exists {
		end := child.walk(words, 0)
		if end == nil {
			return nil
		} else {
			terms := make([]string, 0, 100)
			end.traverseTerms(&terms)
			return terms
		}
	} else {
		return nil
	}
}

func main() {
	tree := new(TrieTree)
	tree.AddTerm("分散")
	tree.AddTerm("分散精力")
	tree.AddTerm("分散投资")
	tree.AddTerm("分布式")
	tree.AddTerm("工程")
	tree.AddTerm("工程师")

	terms := tree.Retrieve("分散")
	fmt.Println(terms)
	terms = tree.Retrieve("人工")
	fmt.Println(terms)
}
Ricky_0528
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Go语言实现对称加密算法AES、DES、3DES和非对称加密算法RSA
JineD的博客
03-31 713
加密和解密使用的是同一个密钥，数据私密性双向保证，也就是加密和解密都不能泄露密码。
Golang常用加密算法
QianLiStudent的博客
10-22 1939
Golang常用加密算法 当我们希望数据不要直接呈现出其结果时我们会选择做加密处理，比如：用户账号的密码、手机号、身份证号等敏感信息通常都是经过加密处理后再写入数据库进行存储的，否则这些信息可能会被拦截而导致信息泄露，因此这就涉及到一个加密的问题。 在密码学中常用的加密算法有3中：Hash算法、编码解码算法、加密解密算法。 ...
Go语言实现对称加密算法AES、DES、3DES和非对称加密算法RSA_golang 对称加密算法
2401_84920056的博客
05-17 1054
消息发送方利用对方的公钥进行加密，消息接受方收到密文时使用自己的私钥进行解密。公钥和密钥生成的时候要有一种关联，要把密钥和公钥保存起来。des——CBC模式，key长度必须为24。AES-128：key长度16 字节。AES-192：key长度24 字节。AES-256：key长度32 字节。对哪一方更重要，哪一方就拿私钥。DES：支持字节长度是8。
golang实现ecc加密解密
reigns的博客
10-16 6818
调包侠就是本人= = package main import ( "crypto/ecdsa" "crypto/elliptic" "crypto/rand" "crypto/sha256" "encoding/hex" "fmt" "github.com/ethereum/go-ethereum/crypto/ecies" "strco
Go中使用加密算法
你是魔鬼吧
08-14 826
哈希算法（MD5 RipeMD160 SHA256 ） DES、3DES对称加密 (Data Encryption Standard，数据加密标准算法) RSA⾮对称加密算法 椭圆曲线算法 椭圆曲线数字签名算法ECDSA 数字签名DSA 编码解码 （base64 base58 base58check）
【软考】——数据结构与算法基础
王萌萌
09-08 2156
前言     刚开始接触软考视频，第一章的内容和《数据结构导论》书中讲解的基本上是一样的，因为已经把《数据结构导论》看过两遍，对于软考视频第一章看起来相对省力的多。     本章节内容在平时也已经很熟悉，常用的数据结构和算法总的来说内容不少，但根本内容不难理解，对其整体内容做个整理。     学习大纲     视频起始给了一张总结性的图片，概括了基本数据结构的整体学习内容：
【软考】—数据结构与算法基础
Alice
09-04 394
前言 编程好比是一辆汽车，而数据结构和算法是汽车内部的变速箱，一个开车的人不懂变速箱的原理也是能开车的，当然不同不懂数据结构和算法的人也能编程，但是程序的性能是不一样的。 数据结构分类 最常用的是线性结构和非线性结构，下面将两个结构细化。 线性表 线性表分为顺序表和链表。顺序表分为栈和队列，链表又分为单链表、循环链表和双链表。链表的操作中需要掌握单链表的结点删除和单链表的...
示例：使用不同的语言练习算法和数据结构
02-04
在Crystal中，你可以找到类似Ruby的语法来实现数据结构和算法，同时由于其静态类型，编译时就能检查错误，使得代码更健壮。 4. **CTF (Capture The Flag)**: CTF通常指的是网络安全竞赛，其中包含解谜、逆向工程和...
知识就是力量：Go中的数据结构，算法和其他功能
02-21
本资源包"knowledge-is-power-go-master"显然聚焦于利用Go语言深入理解和实践数据结构、算法以及其他关键功能。以下是关于这些主题的详细阐述： 1. **数据结构**：数据结构是组织和管理数据的方式，它直接影响程序...
Go语言实现汉诺塔算法
01-20
如数组排序、田忌赛马问题、全排列、递减数排序、Luhn算法、K近邻算法、睡眠排序、AzDG可逆加密算法、树形结构数据比较、寻找数组第二大元素、整数拆分等，这些都展示了Go语言在解决各种算法问题时的强大能力。
leetcode题库-Algorithm:算法库，主要编程语言为Python、Go、C++，包括Leetcode算法和常见加密算法等
06-29
如Leetcode算法和加密算法等。 其中Leetcode算法绝大部分为当时精挑细选的最优解 介绍 本仓库目前以文件夹作区分，主要编程语言为Python、Go、C/C++ Algorithm.py中为常用的基础算法，如二分查找，快速排序等 关于我...
Go 语言课程和项目源码
最新发布
06-21
Go语言基础 Day01 初识Go语言 开发环境搭建 第一个程序 基础语法 基础类型 变量常量与值 变量作用域 运算符 作业 Day02 MODULES工程 格式化输出 条件语句 读取标准输入 循环语句 数据类型转换 Go语言指针 作业 Day03...
Go 加密解密算法小结
m0_63171455的博客
01-20 1486
加密解密在实际开发中应用比较广泛，常见的加解密分为三种，本文就详细的介绍一下Go加密解密算法，具有一定的参考价值，感兴趣的可以了解一下。编程学习资料点击免费领取 前言 加密解密在实际开发中应用比较广泛，常用加解密分为：“对称式”、“非对称式”和”数字签名“。 对称式：对称加密(也叫私钥加密)指加密和解密使用相同密钥的加密算法。具体算法主要有DES算法，3DES算法，TDEA算法，Blowfish算法，RC5算法，IDEA算法。 非对称加密(公钥加密)：指加密和解密使用不同密钥的加密算法，也称为.
8. 何为ECC
fangqiangqi的博客
06-01 1028
ECC
Java加密技术（七）——非对称加密算法最高级ECC
daguairen的博客
08-31 5092
ECC  ECC-Elliptic Curves Cryptography，椭圆曲线密码编码学，是目前已知的公钥体制中，对每比特所提供加密强度最高的一种体制。在软件注册保护方面起到很大的作用，一般的序列号通常由该算法产生。      当我开始整理《Java加密技术（二）》的时候，我就已经在开始研究ECC了，但是关于Java实现ECC算法的资料实在是太少了，无论是国内还是国外的资料，无论是官方还
Go-ecc加密解密详解与代码_ecdsa，2024年最新卧槽
2401_84412912的博客
04-17 1187
对于从来没有接触过网络安全的同学，我们帮你准备了详细的学习成长路线图。可以说是最科学最系统的学习路线，大家跟着这个大的方向学习准没问题。费时一周整理的160+网络安全面试题，金九银十，做网络安全面试里的显眼包！附：ecdsa包的公钥私钥转为ecies对应的密钥的转换代码，全部代码看后面gitee链接。go包没有ecc的加密，这里采用的github上的一个项目的ecies包。对于有1-3年工作经验，想要跳槽的朋友来说，也是很好的温习资料！对于从来没有接触过网络安全的同学，我们帮你准备了详细的。
深入理解 Golang 的 crypto/elliptic：椭圆曲线密码学的实践指南
walkskyer的博客
02-02 784
它相较于传统的加密方法，如RSA，需要更短的密钥长度来提供相同级别的安全性，这使得ECC在移动设备和物联网设备上的应用更为广泛。椭圆曲线密码学是基于椭圆曲线理论的一种公钥加密技术，与传统的基于大数分解的公钥加密技术（如RSA）相比，它可以在相同的安全级别下使用更短的密钥，从而提高效率和安全性。无论您是对椭圆曲线加密感兴趣的初学者，还是希望在Golang项目中实现高级加密功能的开发者，本文都将为您提供宝贵的信息和指导。库的基本使用涉及几个关键步骤，包括椭圆曲线的选择、密钥生成、加密和解密等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Ricky_0528

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值