/
armor.go
99 lines (92 loc) · 1.97 KB
/
armor.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
package main
import (
"bytes"
"encoding/base64"
"io"
)
// Armor returns the ASCII armored version of its input packet. It
// autodetects what kind of armor should be used based on the packet
// header.
func Armor(buf []byte) []byte {
const (
pubBeg = "-----BEGIN PGP PUBLIC KEY BLOCK-----\n\n"
pubEnd = "\n-----END PGP PUBLIC KEY BLOCK-----\n"
secBeg = "-----BEGIN PGP PRIVATE KEY BLOCK-----\n\n"
secEnd = "\n-----END PGP PRIVATE KEY BLOCK-----\n"
sigBeg = "-----BEGIN PGP SIGNATURE-----\n\n"
sigEnd = "\n-----END PGP SIGNATURE-----\n"
)
var beg, end string
switch buf[0] {
case 0xc0 | 2:
beg = sigBeg
end = sigEnd
case 0xc0 | 5:
beg = secBeg
end = secEnd
case 0xc0 | 6:
beg = pubBeg
end = pubEnd
}
var asc bytes.Buffer
asc.WriteString(beg)
wrap := &wrapper{&asc, 64, 0}
b64 := base64.NewEncoder(base64.RawStdEncoding, wrap)
b64.Write(buf)
b64.Close()
asc.WriteString("\n=")
b64 = base64.NewEncoder(base64.RawStdEncoding, &asc)
crc := crc24(buf)
b64.Write([]byte{byte(crc >> 16), byte(crc >> 8), byte(crc)})
b64.Close()
asc.WriteString(end)
return asc.Bytes()
}
// Return CRC-24 checksum for a buffer.
func crc24(buf []byte) int32 {
const (
crc24Init = 0x0b704ce
crc24Poly = 0x1864cfb
)
var crc int32 = crc24Init
for _, b := range buf {
crc ^= int32(b) << 16
for i := 0; i < 8; i++ {
crc <<= 1
if crc&0x1000000 != 0 {
crc ^= crc24Poly
}
}
}
return crc & 0xFFFFFF
}
// wrapper is an io.Writer filter that inserts regular hard line breaks.
type wrapper struct {
w io.Writer
max int
count int
}
func (w *wrapper) Write(p []byte) (int, error) {
for len(p) > 0 {
if w.count == w.max {
if _, err := w.w.Write([]byte{10}); err != nil {
return 0, err
}
w.count = 0
}
left := w.max - w.count
var line []byte
if len(p) > left {
line = p[:left]
} else {
line = p
}
p = p[len(line):]
w.count += len(line)
_, err := w.w.Write(line)
if err != nil {
return 0, err
}
}
return len(p), nil
}