/
util.go
106 lines (101 loc) · 2.26 KB
/
util.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
package main
import (
"crypto/des"
"crypto/rand"
"log"
)
// function to (un)scramble a key
func Scramble(input []byte) []byte {
// copy input, otherwise we'll be changing the key
key := make([]byte, len(input))
copy(key, input)
key[3] ^= 0x05
key[4] ^= 0x23
key[9] ^= 0x29
key[1] ^= 0x2D
key[6] ^= 0x39
key[20] ^= 0x44
key[8] ^= 0x45
key[16] ^= 0x45
key[5] ^= 0x49
key[18] ^= 0x50
key[23] ^= 0x54
key[0] ^= 0x55
key[22] ^= 0x69
key[2] ^= 0x6A
key[15] ^= 0x88
key[19] ^= 0x8A
key[12] ^= 0x94
key[17] ^= 0xA3
key[7] ^= 0xA8
key[21] ^= 0xAA
key[14] ^= 0xB5
key[13] ^= 0xC2
key[10] ^= 0xD3
key[11] ^= 0xE9
return key
}
// 3DES ECB descryption.
// We need ECB which is not there in go, so implement here.
// https://code.google.com/p/go/issues/detail?id=5597
func Decrypt3DESECB(input []byte, key []byte) []byte {
if len(key) != 24 {
log.Panic("Key must be 24 bytes")
}
block, err := des.NewTripleDESCipher(key)
if err != nil {
log.Panic(err)
}
bs := block.BlockSize()
//log.Printf("Block size: %d", bs)
if len(input)%bs != 0 {
log.Panic("Input should be a multiple of blocksize")
}
//log.Printf("Input length: %d", len(input))
m := len(input) / bs
//log.Printf("Going for %d cycles", m)
data := []byte{}
buf := make([]byte, bs)
for i := 0; i < m; i++ {
//log.Printf("%d: byte: %s", i, hex.EncodeToString(input[0:bs]))
block.Decrypt(buf, input)
input = input[bs:]
data = append(data, buf...)
}
return data
}
func Encrypt3DESECB(input []byte, key []byte) []byte {
if len(key) != 24 {
log.Panic("Key must be 24 bytes")
}
block, err := des.NewTripleDESCipher(key)
if err != nil {
log.Panic(err)
}
bs := block.BlockSize()
//log.Printf("Block size: %d", bs)
if len(input)%bs != 0 {
log.Panic("Input should be a multiple of blocksize")
}
//log.Printf("Input length: %d", len(input))
m := len(input) / bs
//log.Printf("Going for %d cycles", m)
data := []byte{}
buf := make([]byte, bs)
for i := 0; i < m; i++ {
//log.Printf("%d: byte: %s", i, hex.EncodeToString(input[0:bs]))
block.Encrypt(buf, input)
input = input[bs:]
data = append(data, buf...)
}
return data
}
// Generate a random key (3DES)
func GenerateKey() ([]byte) {
key := make([]byte, 24)
_, err := rand.Read(key)
if err != nil {
log.Panic(err)
}
return key
}