fix: encrypt replace with RSA

zhangzengfei

2019-11-21 99a38065bf10619a2677cb6dcbfe93ee16de69d1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
package licence
 
import (
    "encoding/base64"
    "encoding/json"
    "io/ioutil"
    "os"
    "time"
)
 
type RegisterCode struct {
    MachineCode string
    Company     string
    Email       string
    Phone       string
    Version     string
}
 
type Licence struct {
    RegCode   RegisterCode
    Expires   int64
    Timestamp int64
}
 
const (
    ValidationErrorDecrypt          uint32 = iota + 1 // Licence is malformed
    ValidationErrorUnverifiableHost                   // Host unauthorized
    ValidationErrorExpired                            // Signature expired
    ValidationErrorMalformed
 
    Version = "1.0.1"
    aesKey  = "www.aiotlink.com"
)
 
func GetRegisterCode(company, email, phone string) string {
    mCode := GetMachineCode()
 
    regCode := RegisterCode{mCode, company, email, phone, Version}
 
    json, _ := json.Marshal(regCode)
 
    return AESEncodeStr(json, aesKey)
}
 
func DecryptRegisterCode(regCode string) []byte {
    return AESDecodeStr(regCode, aesKey)
}
 
func GenerateLicence(regCode, timeOut string, privateKey []byte) (string, error) {
    timeLayout := "2006-01-02 15:04:05"  //转化所需模板
    loc, _ := time.LoadLocation("Local") //获取时区
    tmp, _ := time.ParseInLocation(timeLayout, timeOut, loc)
    exp := tmp.Unix()
    now := time.Now().Unix()
 
    regCodeText := AESDecodeStr(regCode, aesKey)
    var registerCode RegisterCode
    if err := json.Unmarshal(regCodeText, &registerCode); err != nil {
        return "", err
    }
 
    licence := Licence{registerCode, exp, now}
    json, err := json.Marshal(licence)
    if err != nil {
        return "", err
    }
 
    RSA := &RSASecurity{}
    if err := RSA.SetPrivateKey(privateKey); err != nil {
        return "", err
    }
 
    licenceHex, err := RSA.PriKeyENCTYPT(json)
    if err != nil {
        return "", err
    }
 
    licenceText := base64.StdEncoding.EncodeToString(licenceHex)
 
    return licenceText, nil
}
 
func DecryptLicence(licencePath, publicKeyPath string) ([]byte, error) {
    var publicKey, licenceCode []byte
    var fdLic, fdPub *os.File
    var err error
 
    // 读取Licence File
    fdLic, err = os.Open(licencePath)
    if err != nil {
        return nil, err
    }
    defer fdLic.Close()
 
    licenceCode, err = ioutil.ReadAll(fdLic)
    if err != nil {
        return nil, err
    }
 
    // 读取公钥
    fdPub, err = os.Open(publicKeyPath)
    if err != nil {
        return nil, err
    }
    defer fdPub.Close()
 
    publicKey, err = ioutil.ReadAll(fdPub)
    if err != nil {
        return nil, err
    }
 
    RSA := &RSASecurity{}
    if err := RSA.SetPublicKey(publicKey); err != nil {
        return nil, err
    }
 
    licenceHex, _ := base64.StdEncoding.DecodeString(string(licenceCode))
 
    return RSA.PubKeyDECRYPT(licenceHex)
}
 
func VerifyLicence(licencePath, publicKeyPath string) uint32 {
    licenceText, err := DecryptLicence(licencePath, publicKeyPath)
    if err != nil {
        return ValidationErrorDecrypt
    }
 
    var licence Licence
 
    if err := json.Unmarshal(licenceText, &licence); err != nil {
        return ValidationErrorMalformed
    }
 
    // 判断过期
    now := time.Now().Unix()
    if now > licence.Expires {
        return ValidationErrorExpired
    }
 
    // 判断机器码
    mCode := GetMachineCode()
    if licence.RegCode.MachineCode != mCode {
        return ValidationErrorUnverifiableHost
    }
 
    return 0
}