-
Notifications
You must be signed in to change notification settings - Fork 389
/
crypto.go
134 lines (120 loc) · 3.15 KB
/
crypto.go
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
/**
* Tencent is pleased to support the open source community by making Polaris available.
*
* Copyright (C) 2019 THL A29 Limited, a Tencent company. All rights reserved.
*
* Licensed under the BSD 3-Clause License (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://opensource.org/licenses/BSD-3-Clause
*
* Unless required by applicable law or agreed to in writing, software distributed
* under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
package plugin
import (
"fmt"
"os"
"sync"
)
var (
cryptoManagerOnce sync.Once
cryptoManager *defaultCryptoManager
)
// Crypto Crypto interface
type Crypto interface {
Plugin
GenerateKey() ([]byte, error)
Encrypt(plaintext string, key []byte) (cryptotext string, err error)
Decrypt(cryptotext string, key []byte) (string, error)
}
// GetCrypto get the crypto plugin
func GetCryptoManager() CryptoManager {
if cryptoManager != nil {
return cryptoManager
}
cryptoManagerOnce.Do(func() {
var (
entries []ConfigEntry
)
if len(config.Crypto.Entries) != 0 {
entries = append(entries, config.Crypto.Entries...)
} else {
entries = append(entries, ConfigEntry{
Name: config.Crypto.Name,
Option: config.Crypto.Option,
})
}
cryptoManager = &defaultCryptoManager{
cryptos: make(map[string]Crypto),
options: entries,
}
if err := cryptoManager.Initialize(); err != nil {
log.Errorf("Crypto plugin init err: %s", err.Error())
os.Exit(-1)
}
})
return cryptoManager
}
// CryptoManager crypto algorithm manager
type CryptoManager interface {
Name() string
Initialize() error
Destroy() error
GetCryptoAlgoNames() []string
GetCrypto(algo string) (Crypto, error)
}
// defaultCryptoManager crypto algorithm manager
type defaultCryptoManager struct {
cryptos map[string]Crypto
options []ConfigEntry
}
func (c *defaultCryptoManager) Name() string {
return "CryptoManager"
}
func (c *defaultCryptoManager) Initialize() error {
for i := range c.options {
entry := c.options[i]
item, exist := pluginSet[entry.Name]
if !exist {
log.Errorf("plugin Crypto not found target: %s", entry.Name)
continue
}
crypto, ok := item.(Crypto)
if !ok {
log.Errorf("plugin target: %s not Crypto", entry.Name)
continue
}
if err := crypto.Initialize(&entry); err != nil {
return err
}
c.cryptos[entry.Name] = crypto
}
return nil
}
func (c *defaultCryptoManager) Destroy() error {
for i := range c.cryptos {
if err := c.cryptos[i].Destroy(); err != nil {
return err
}
}
return nil
}
func (c *defaultCryptoManager) GetCryptoAlgoNames() []string {
var names []string
for name := range c.cryptos {
names = append(names, name)
}
return names
}
func (c *defaultCryptoManager) GetCrypto(algo string) (Crypto, error) {
crypto, ok := c.cryptos[algo]
if !ok {
log.Errorf("plugin Crypto not found target: %s", algo)
return nil, fmt.Errorf("plugin Crypto not found target: %s", algo)
}
return crypto, nil
}