go-crypto

使用起来比 C++方便多了

md5

import (
"crypto/md5"
"fmt"
"io"
)

func main() {
str := "abc123"

//方法一
data := []byte(str)
has := md5.Sum(data)
md5str1 := fmt.Sprintf("%x", has) //将[]byte转成16进制

fmt.Println(md5str1)

//方法二

w := md5.New()
io.WriteString(w, str)   //将str写入到w中
md5str2: = fmt.Sprintf("%x", w.Sum(nil))  //w.Sum(nil)将w的hash转成[]byte格式

fmt.Println(mdtstr2)
}

打印结果：

e99a18c428cb38d5f260853678922e03

e99a18c428cb38d5f260853678922e03

// new file
import (
	"crypto/md5"
	"fmt"
	"io"
	"log"
	"os"
)

func main() {
	f, err := os.Open("file.txt")
	if err != nil {
		log.Fatal(err)
	}
	defer f.Close()

	h := md5.New()
	if _, err := io.Copy(h, f); err != nil {
		log.Fatal(err)
	}

	fmt.Printf("%x", h.Sum(nil))
}

random

rand.Seed(time.Now().Unix())
rand.Seed(int64(time.Now().UnixNano()))
fmt.Println(rand.Int())       // int随机值，返回值为int
ver.nonce = rand.Uint64()
fmt.Println(rand.Float64())   // 64位float随机值，返回值为float64

// 根据数组大小生成随机数
limb := make([]byte, 8)
rand.Seed(time.Now().Unix())
rand.Read(limb)

fmt.Println(rand.Int())       // int随机值，返回值为int
fmt.Println(rand.Intn(100))   // [0,100)的随机值，返回值为int
fmt.Println(rand.Int31())     // 31位int随机值，返回值为int32
fmt.Println(rand.Int31n(100)) // [0,100)的随机值，返回值为int32

RSA 加解密

import (
    "crypto/rand"
	"crypto/rsa"
	"crypto/x509"
	"encoding/pem"
	"errors"
	"fmt"
	"flag"
	"encoding/hex"
)

// 加密
func RsaEncrypt(publicKey []byte, 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 []byte, ciphertext []byte) ([]byte, error) {
	//解码pem格式的私钥------BEGIN RSA PRIVATE KEY-----   -----END RSA PRIVATE KEY-----
	block, _ := pem.Decode(privateKey)
	if block == nil {
		return nil, errors.New("private key error!")
	}

	//打印出私钥类型
	//fmt.Println(block.Type)
	//fmt.Println(block.Headers)
	var key interface{}
	var errParsePK error
	if block.Type == "RSA PRIVATE KEY" {
		//RSA PKCS1
		key, errParsePK = x509.ParsePKCS1PrivateKey(block.Bytes)
	} else if block.Type == "PRIVATE KEY" {
		//pkcs8格式的私钥解析
		key, errParsePK = x509.ParsePKCS8PrivateKey(block.Bytes)
	}

	if errParsePK != nil {
		return nil, errParsePK
	}
	priv := key.(*rsa.PrivateKey)

	return rsa.DecryptPKCS1v15(rand.Reader, priv, ciphertext)
}


func GenRsaKey(bits int) error {
	// 生成私钥文件
	privateKey, err := rsa.GenerateKey(rand.Reader, bits)
	if err != nil {
		return err
	}
	derStream := x509.MarshalPKCS1PrivateKey(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
}


func main() {

	plainMsg := flag.String("plainMsg", "", "plain message to encrypt")
	encMsg := flag.String("encMsg", "", "ecrypted message to decrypt")
	isEnc := flag.Bool("isEnc", false, "1 is encrypt, 0 is decrypt")
	flag.Parse()

	if *plainMsg == "" && *encMsg == "" {
		fmt.Println("Error@!@: no param")
		return
	}

	if *isEnc {
		encData, err := RsaEncrypt([]byte(pub), []byte(*plainMsg))
		if err != nil {
			fmt.Println("Error@!@")
			fmt.Println(err.Error())
		}
		fmt.Println(hex.EncodeToString(encData))
	} else {
		bData, err := hex.DecodeString(*encMsg)
		if err != nil {
			fmt.Println("Error@!@")
			fmt.Println(err.Error())
			return
		}
		origData, err := RsaDecrypt([]byte(priv), bData)
		if err != nil {
			fmt.Println("Error@!@")
			fmt.Println(err.Error())
			return
		}
		fmt.Println(string(origData))
	}
}