RSA生成秘钥对&加解密&加签验签

2019-03-19

RSA加密简介

RSA加密是一种非对称加密。可以在不直接传递密钥的情况下，完成解密。这能够确保信息的安全性，避免了直接传递密钥所造成的被破解的风险。是由一对密钥来进行加解密的过程，分别称为公钥和私钥。两者之间有数学相关，该加密算法的原理就是对一极大整数做因数分解的困难性来保证安全性。通常个人保存私钥，公钥是公开的（可能同时多人持有）。

RSA概括

公钥加密、私钥解密、私钥签名、公钥验签。

GO语言生成RSA秘钥对

生成秘钥对供JAVA对接，因此使用x509.MarshalPKCS8PrivateKey方法生成PKCS#8字节的秘钥

package main

import (

    "crypto/rand"

    "crypto/rsa"

    "crypto/x509"

    "encoding/pem"

    "os"

)

 

func main() {

    //rsa 密钥文件产生

    GenRsaKey(1024)

}

 

func GenRsaKey(bits int) error {

    // 生成私钥文件

    privateKey, err := rsa.GenerateKey(rand.Reader, bits)

    if err != nil {

        return err

    }

    derStream, _ := x509.MarshalPKCS8PrivateKey(privateKey)

    block := &pem.Block{

        Type:  "RSA PRIVATE KEY",

        Bytes: derStream,

    }

    file, err := os.Create("private.pem")

    if err != nil {

        return err

    }

    err = pem.Encode(file, block)

    if err != nil {

        return err

    }

    // 生成公钥文件

    publicKey := &privateKey.PublicKey

    derPkix, err := x509.MarshalPKIXPublicKey(publicKey)

    if err != nil {

        return err

    }

    block = &pem.Block{

        Type:  "PUBLIC KEY",

        Bytes: derPkix,

    }

    file, err = os.Create("public.pem")

    if err != nil {

        return err

    }

    err = pem.Encode(file, block)

    if err != nil {

        return err

    }

    return nil

}

GO语言RSA加解密

公钥加密（分段）：

// RSAEncrypt 解析公钥

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)

    if err != nil {

        return nil, err

    }

    // 类型断言

    pub := pubInterface.(*rsa.PublicKey)

    //加密

    return rsaEncrypt(pub, string(origData))

}

 

// rsaEncrypt 数据加密

func rsaEncrypt(pub *rsa.PublicKey, data string) ([]byte, error) {

    partLen := pub.N.BitLen()/8 - 11

    chunks := split([]byte(data), partLen)

 

    buffer := bytes.NewBufferString("")

    for _, chunk := range chunks {

        bts, err := rsa.EncryptPKCS1v15(rand.Reader, pub, chunk)

        if err != nil {

            return nil, err

        }

        buffer.Write(bts)

    }

 

    return buffer.Bytes(), nil

}

 

func split(buf []byte, lim int) [][]byte {

    var chunk []byte

    chunks := make([][]byte, 0, len(buf)/lim+1)

    for len(buf) >= lim {

        chunk, buf = buf[:lim], buf[lim:]

        chunks = append(chunks, chunk)

    }

    if len(buf) > 0 {

        chunks = append(chunks, buf[:])

    }

    return chunks

}

私钥解密（分段）：

因对接java，故使用x509.ParsePKCS8PrivateKey()读取私钥，分段解密

// rsaPrivateDe 解密读取秘钥

func rsaPrivateDe(cryptoText string) (string, error) {

    block, _ := pem.Decode(privateKey)

    if block == nil {

        return "", errors.New("private key error!")

    }

    privInterface, err := x509.ParsePKCS8PrivateKey(block.Bytes)

    if err != nil {

        return "", err

    }

    // 类型断言

    priv, _ := privInterface.(*rsa.PrivateKey)

    plainText, err := RsaPrivateDecrypt(priv, cryptoText)

    if err != nil {

        fmt.Println("RsaPrivateDecrypt error ：", err)

        return "", err

    }

    return plainText, nil

}

 

// RsaPrivateDecrypt 私钥解密

func RsaPrivateDecrypt(priv *rsa.PrivateKey, encrypted string) (string, error) {

    partLen := 1024 / 8

    raw, err := base64.StdEncoding.DecodeString(encrypted)

    chunks := split([]byte(raw), partLen)

 

    buffer := bytes.NewBufferString("")

    for _, chunk := range chunks {

        decrypted, err := rsa.DecryptPKCS1v15(rand.Reader, priv, chunk)

        if err != nil {

            return "", err

        }

        buffer.Write(decrypted)

    }

    return buffer.String(), err

}

GO语言RSA加签验签

私钥加签：

// 私钥加签

func RsaSignWithSha1Hex(data string) (string, error) {

    block, _ := pem.Decode(privateKey)

    if block == nil {

        return "", errors.New("private key error!")

    }

    privInterface, err := x509.ParsePKCS8PrivateKey(block.Bytes)

    if err != nil {

        return "", err

    }

    // 类型断言

    priv, _ := privInterface.(*rsa.PrivateKey)

    h := md5.New()  // 对接JAVA使用MD5加密（也可以使用sha1.New()进行加密，但JAVA需要使用Signature signature = Signature.getInstance("SHA1WithRSA")验签） 

    h.Write([]byte([]byte(data)))

    hash := h.Sum(nil)

    signature, err := rsa.SignPKCS1v15(rand.Reader, priv, crypto.MD5, hash[:])  // 使用MD5加签

    if err != nil {

        return "", err

    }

    out := base64.StdEncoding.EncodeToString(signature)  // 加签使用base64编码，验签时需先base64解码

    return out, nil

}

公钥验签：

func RsaVerySignWithSha1Base64(originalData, signData string) error {

    sign, err := base64.StdEncoding.DecodeString(signData) // base64解码

    if err != nil {

        return err

    }

 

    //解密pem格式的公钥

    block, _ := pem.Decode(pub)

    if block == nil {

        return errors.New("public key error")

    }

    // 解析公钥

    pubInterface, err := x509.ParsePKIXPublicKey(block.Bytes)

    if err != nil {

        return err

    }

    // 类型断言

    pub := pubInterface.(*rsa.PublicKey)

    if err != nil {

        return err

    }

    hash := sha1.New() // 使用SHA1算法验签

    hash.Write([]byte(originalData))

    return rsa.VerifyPKCS1v15(pub, crypto.SHA1, hash.Sum(nil), sign)

}

展开全文 >>

RedisPubSub

2018-10-30

Redis 发布订阅

Redis 发布订阅(pub/sub)是一种消息通信模式：发送者(pub)发送消息，订阅者(sub)接收消息。

Redis 客户端可以订阅任意数量的频道。

下图展示了频道 channel1 ，以及订阅这个频道的三个客户端 —— client2 、 client5 和 client1 之间的关系：

当有新消息通过 PUBLISH 命令发送给频道 channel1 时，这个消息就会被发送给订阅它的三个客户端：

操作示例：

package main

import (
    "github.com/garyburd/redigo/redis"
    "fmt"
    "time"
)

func Subs() {  //订阅者
    conn, err := redis.Dial("tcp", "10.1.210.69:6379")
    if err != nil {
        fmt.Println("connect redis error :", err)
        return
    }
    defer conn.Close()
    psc := redis.PubSubConn{conn}
    psc.Subscribe("channel1") //订阅channel1频道
    for {
        switch v := psc.Receive().(type) {
        case redis.Message:
            fmt.Printf("%s: message: %s\n", v.Channel, v.Data)
        case redis.Subscription:
            fmt.Printf("%s: %s %d\n", v.Channel, v.Kind, v.Count)
        case error:
            fmt.Println(v)
            return
        }
    }
}

func Push(message string)  { //发布者
    conn, _ := redis.Dial("tcp", "10.1.210.69:6379")
    _,err1 := conn.Do("PUBLISH", "channel1", message)
       if err1 != nil {
             fmt.Println("pub err: ", err1)
                 return
            }

}

func main()  {
    go Subs()
    go Push("this is wd")
    time.Sleep(time.Second*3)
}
//channel1: subscribe 1
//channel1: message: this is wd

但是在docker中运行时，docker的网络模式会影响redis订阅

部分转自：http://www.runoob.com/redis/redis-pub-sub.html

展开全文 >>

网络协议

2018-09-19

TCP：传输控制协议

面向对象的、可靠的、基于字节流的运输层通信协议。提供的是面向连接、可靠的字节流服务。客户和服务器彼此交换数据前，必须在双方建立一个TCP连接，之后才能传输数据，TCP提供超时重发、丢弃重复数据、检验数据、流量控制等功能，保证数据能从一端传到另一端。

UDP：用户数据包协议

是一个简单的面向数据报的传输层协议。UDP不提供可靠性，他只是把应用程序传给IP层的数据报发送出去，但是并不能保证它们达到目的地，无重发机智，传输速度快。

TCP三次握手过程：

http协议：超文本传输协议（Hyper Text Transfer Protocol ）

HTTP是用于从万维网（WWW:World Wide Web ）服务器传输超文本到本地浏览器的传送协议。
HTTP是一个基于TCP/IP通信协议来传递数据（HTML 文件, 图片文件, 查询结果等）。
HTTP是一个属于应用层的面向对象的协议，由于其简捷、快速的方式，适用于分布式超媒体信息系统。

主要特点：

1、简单快速：客户向服务器请求服务时，只需传送请求方法和路径。请求方法常用的有GET、HEAD、POST。每种方法规定了客户与服务器联系的类型不同。由于HTTP协议简单，使得HTTP服务器的程序规模小，因而通信速度很快。

2、灵活：HTTP允许传输任意类型的数据对象。正在传输的类型由Content-Type加以标记。

3、无连接：无连接的含义是限制每次连接只处理一个请求。服务器处理完客户的请求，并收到客户的应答后，即断开连接。采用这种方式可以节省传输时间。

4、无状态：HTTP协议是无状态协议。无状态是指协议对于事务处理没有记忆能力。缺少状态意味着如果后续处理需要前面的信息，则它必须重传，这样可能导致每次连接传送的数据量增大。另一方面，在服务器不需要先前信息时它的应答就较快。

5、支持B/S及C/S模式。

TCP/IP协议

应用层：HTTP、SMTP(简单电邮)、FTP（文件传输）、Telnet（网络远程访问）
传输层：TCP、UDP
网络层
数据链路层

http协议部分转自：https://www.cnblogs.com/ranyonsue/p/5984001.html

展开全文 >>

sql

2018-09-14

SQL调优的几种方法：

建立必要的索引
使用预编译查询
调整where字句中的连接顺序：DBMS自下而上解析where字句，表连接最好卸载其他where条件之前
尽量将多条SQL语句压缩到一句SQL中：减少编译时间
用where替换having：where在聚合前刷选记录，having在检查完成后过滤
使用表的别名：减少解析时间
避免在索引上使用计算

事务的四大基本属性（ACID）：

原子性：不可分割的工作单位
一致性：操作前后数据移植
隔离性：并发不互相干扰
持久性：操作永久

事务的特性：

在存储引擎实现
有开销
一条sql语句也是一个事务

事务是指逻辑上对数据的一组操作，这组操作要么一次成功，要么一次失败。是一个不可分割的一个工作单位。

展开全文 >>

goroutines&channels

2018-09-12

高并发是GO语言最大的特性，谈及并发一定要提到Go语言中的Goroutine和Channel了：

Goroutine是并发的执行单元。
Channel是Goroutine之间的通信机制。

goroutine在go中被称为线程，那么线程，进程，协程的差别在哪里呢？

进程：程序的一个实例
线程：程序的一个执行流
协程：轻量级的线程，在切换内核态时可控切换时机，并且切换的代价小

channel分为无缓存channel（同步channel）和带缓存channel：

无缓存channel：

例如

g2接收数据happends before唤醒g1(happends before:并非时间上，而是保证在此之前已经完成)

基于无缓存Channels的发送和接收操作将导致两个goroutine做一次同步操作，因此称为同步channel。串联的channel行程pipeline(管道)。

带缓存channel：

带缓存的Channel内部持有一个元素队列。队列的最大容量是在调用make函数创建channel时通过第二个参数指定的。。下面的语句创建了一个可以持有三个字符串元素的带缓存Channel。图8.2是ch变量对应的channel的图形表示形式。

向缓存Channel的发送操作就是向内部缓存队列的尾部插入元素，接收操作则是从队列的头部删除元素。如果内部缓存队列是满的，那么发送操作将阻塞直到因另一个goroutine执行接收操作而释放了新的队列空间。相反，如果channel是空的，接收操作将阻塞直到有另一个 goroutine执行发送操作而向队列插入元素。

Go语言中的并发程序模型分为以下两种：

顺序通信进程（ communicating sequential processes ，缩写为CSP）。在CSP中，程序是一组中间没有共享状态的平行运行的处理过程，它们之间使用管道进行通信和控制同步。
多线程共享内存（传统模型）。

而传统的多线程共享内存就会涉及到数据竞争（Data Race）的问题，如何避免数据竞争是并发中需要解决的头号问题，以下有三种避免数据竞争的方法：

不要去写变量
避免从多个goroutine访问变量
允许从多个goroutine访问变量，但同一时刻最多只有一个goroutine在访问变量

如若在多goroutine之间已经存在共享变量，那么在使用到共享变量的时候，需要一些限定或是锁，来确保变量安全：

限定缓存为1的chan,保证每次只有一个goroutine访问
sync.Mutex()互斥锁
sync.RWMutex读写锁

另外Go语言中，还有竞争检测器，使用 go run /test -race flag 可在调试中检测是否有数据竞争存在。

展开全文 >>

使用xorm-cmd反向生成数据库结构

2018-08-23

使用xorm工具，根据数据库自动生成 go 代码

关于 xorm

xorm是一个简单而强大的Go语言ORM库. 通过它可以使数据库操作非常简便。我在项目中经常使用，它的特性如下：

支持Struct和数据库表之间的灵活映射，并支持自动同步表结构

事务支持

支持原始SQL语句和ORM操作的混合执行

使用连写来简化调用

支持使用Id, In, Where, Limit, Join, Having, Table, Sql, Cols等函数和结构体等方式作为条件

支持级联加载Struct

支持LRU缓存(支持memory, memcache, leveldb, redis缓存Store) 和 Redis缓存

支持反转，即根据数据库自动生成xorm的结构体

支持事件

支持created, updated, deleted和version记录版本（即乐观锁）

想了解更多请移步：http://www.xorm.io/

xorm 工具

xorm 是一组数据库操作命令的工具，包含如下命令：

reverse 反转一个数据库结构，生成代码

shell 通用的数据库操作客户端，可对数据库结构和数据操作

dump Dump数据库中所有结构和数据到标准输出

source 从标注输入中执行SQL文件

driver 列出所有支持的数据库驱动

首先下载该工具：

1	go get github.com/go-xorm/cmd/xorm

同时需要安装对应的 driver :

go get github.com/go-sql-driver/mysql  //MyMysql
go get github.com/ziutek/mymysql/godrv  //MyMysql
go get github.com/lib/pq  //Postgres
go get github.com/mattn/go-sqlite3  //SQLite

还需要下载 xorm ：

1	go get github.com/go-xorm/xorm

编译 cmd/xorm 会生成 xorm 工具，假如环境变量。

这时候，执行 xorm help reverse 能获取帮助信息如下：

usage: xorm reverse [-s] driverName datasourceName tmplPath [generatedPath] [tableFilterReg]

according database's tables and columns to generate codes for Go, C++ and etc.

    -s                Generated one go file for every table
    driverName        Database driver name, now supported four: mysql mymysql sqlite3 postgres
    datasourceName    Database connection uri, for detail infomation please visit driver's project page
    tmplPath          Template dir for generated. the default templates dir has provide 1 template
    generatedPath     This parameter is optional, if blank, the default value is model, then will
                      generated all codes in model dir
    tableFilterReg    Table name filter regexp

例如：.\xorm.exe reverse mysql root:123456@(127.0.0.1:3306)/source?charset=utf8 F:\gopro\src\github.com\go-xorm\cmd\xorm\templates\goxorm

反向生成的model将会在github.com\go-xorm\cmd\xorm 目录下

命令行添加-s后，数据库的表结构将会都存在于struct.go文件中

另外在github.com\go-xorm\cmd\xorm\templates\goxorm目录下的config文件可以配置go-xorm/cmd运行的语言、是否生成json、前缀。

struct.go.tpl则可以设置反向生成结构表的模板

部分转载于：https://www.cnblogs.com/artong0416/p/7456674.html

展开全文 >>

Hello World

2018-08-23

Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.

Quick Start

Create a new post

1	$ hexo new "My New Post"

More info: Writing

Run server

1	$ hexo server

More info: Server

Generate static files

1	$ hexo generate

More info: Generating

Deploy to remote sites

1	$ hexo deploy

More info: Deployment

展开全文 >>

RSA加密简介

RSA概括

GO语言生成RSA秘钥对

GO语言RSA加解密

公钥加密（分段）：

私钥解密（分段）：

GO语言RSA加签验签

私钥加签：

公钥验签：

Redis 发布订阅

TCP：传输控制协议

UDP：用户数据包协议

TCP三次握手过程：

http协议：超文本传输协议（Hyper Text Transfer Protocol ）

主要特点：

TCP/IP协议

SQL调优的几种方法：

事务的四大基本属性（ACID）：

事务的特性：

高并发是GO语言最大的特性，谈及并发一定要提到Go语言中的Goroutine和Channel了：

goroutine在go中被称为线程，那么线程，进程，协程的差别在哪里呢？

channel分为无缓存channel（同步channel）和带缓存channel：

无缓存channel：

带缓存channel：

Go语言中的并发程序模型分为以下两种：

使用xorm工具，根据数据库自动生成 go 代码

关于 xorm

xorm 工具

Quick Start

Create a new post

Run server

Generate static files

Deploy to remote sites