Debian Codegraph @

sign_test.go

raw ◀ ▶
Source reconstructed at patch state 0 of 1 — not the installed (fully patched) source.
1 Debian patch touch this file
1 package pkcs7
2
3 import (
4 "bytes"
5 "crypto/dsa"
6 "crypto/x509"
7 "encoding/asn1"
8 "encoding/pem"
9 "fmt"
10 "io/ioutil"
11 "log"
12 "math/big"
13 "os"
14 "os/exec"
15 "testing"
16 )
17
18 func TestSign(t *testing.T) {
19 content := []byte("Hello World")
20 sigalgs := []x509.SignatureAlgorithm{
21 x509.SHA1WithRSA,
22 x509.SHA256WithRSA,
23 x509.SHA512WithRSA,
24 x509.ECDSAWithSHA1,
25 x509.ECDSAWithSHA256,
26 x509.ECDSAWithSHA384,
27 x509.ECDSAWithSHA512,
28 }
29 for _, sigalgroot := range sigalgs {
30 rootCert, err := createTestCertificateByIssuer("PKCS7 Test Root CA", nil, sigalgroot, true)
31 if err != nil {
32 t.Fatalf("test %s: cannot generate root cert: %s", sigalgroot, err)
33 }
34 truststore := x509.NewCertPool()
35 truststore.AddCert(rootCert.Certificate)
36 for _, sigalginter := range sigalgs {
37 interCert, err := createTestCertificateByIssuer("PKCS7 Test Intermediate Cert", rootCert, sigalginter, true)
38 if err != nil {
39 t.Fatalf("test %s/%s: cannot generate intermediate cert: %s", sigalgroot, sigalginter, err)
40 }
41 var parents []*x509.Certificate
42 parents = append(parents, interCert.Certificate)
43 for _, sigalgsigner := range sigalgs {
44 signerCert, err := createTestCertificateByIssuer("PKCS7 Test Signer Cert", interCert, sigalgsigner, false)
45 if err != nil {
46 t.Fatalf("test %s/%s/%s: cannot generate signer cert: %s", sigalgroot, sigalginter, sigalgsigner, err)
47 }
48 for _, testDetach := range []bool{false, true} {
49 log.Printf("test %s/%s/%s detached %t\n", sigalgroot, sigalginter, sigalgsigner, testDetach)
50 toBeSigned, err := NewSignedData(content)
51 if err != nil {
52 t.Fatalf("test %s/%s/%s: cannot initialize signed data: %s", sigalgroot, sigalginter, sigalgsigner, err)
53 }
54
55 // Set the digest to match the end entity cert
56 signerDigest, _ := getDigestOIDForSignatureAlgorithm(signerCert.Certificate.SignatureAlgorithm)
57 toBeSigned.SetDigestAlgorithm(signerDigest)
58
59 if err := toBeSigned.AddSignerChain(signerCert.Certificate, *signerCert.PrivateKey, parents, SignerInfoConfig{}); err != nil {
60 t.Fatalf("test %s/%s/%s: cannot add signer: %s", sigalgroot, sigalginter, sigalgsigner, err)
61 }
62 if testDetach {
63 toBeSigned.Detach()
64 }
65 signed, err := toBeSigned.Finish()
66 if err != nil {
67 t.Fatalf("test %s/%s/%s: cannot finish signing data: %s", sigalgroot, sigalginter, sigalgsigner, err)
68 }
69 pem.Encode(os.Stdout, &pem.Block{Type: "PKCS7", Bytes: signed})
70 p7, err := Parse(signed)
71 if err != nil {
72 t.Fatalf("test %s/%s/%s: cannot parse signed data: %s", sigalgroot, sigalginter, sigalgsigner, err)
73 }
74 if testDetach {
75 p7.Content = content
76 }
77 if !bytes.Equal(content, p7.Content) {
78 t.Errorf("test %s/%s/%s: content was not found in the parsed data:\n\tExpected: %s\n\tActual: %s", sigalgroot, sigalginter, sigalgsigner, content, p7.Content)
79 }
80 if err := p7.VerifyWithChain(truststore); err != nil {
81 t.Errorf("test %s/%s/%s: cannot verify signed data: %s", sigalgroot, sigalginter, sigalgsigner, err)
82 }
83 if !signerDigest.Equal(p7.Signers[0].DigestAlgorithm.Algorithm) {
84 t.Errorf("test %s/%s/%s: expected digest algorithm %q but got %q",
85 sigalgroot, sigalginter, sigalgsigner, signerDigest, p7.Signers[0].DigestAlgorithm.Algorithm)
86 }
87 }
88 }
89 }
90 }
91 }
92
93 func TestDSASignAndVerifyWithOpenSSL(t *testing.T) {
94 content := []byte("Hello World")
95 // write the content to a temp file
96 tmpContentFile, err := ioutil.TempFile("", "TestDSASignAndVerifyWithOpenSSL_content")
97 if err != nil {
98 t.Fatal(err)
99 }
100 ioutil.WriteFile(tmpContentFile.Name(), content, 0755)
101
102 block, _ := pem.Decode([]byte(dsaPublicCert))
103 if block == nil {
104 t.Fatal("failed to parse certificate PEM")
105 }
106 signerCert, err := x509.ParseCertificate(block.Bytes)
107 if err != nil {
108 t.Fatal("failed to parse certificate: " + err.Error())
109 }
110
111 // write the signer cert to a temp file
112 tmpSignerCertFile, err := ioutil.TempFile("", "TestDSASignAndVerifyWithOpenSSL_signer")
113 if err != nil {
114 t.Fatal(err)
115 }
116 ioutil.WriteFile(tmpSignerCertFile.Name(), dsaPublicCert, 0755)
117
118 priv := dsa.PrivateKey{
119 PublicKey: dsa.PublicKey{Parameters: dsa.Parameters{P: fromHex("fd7f53811d75122952df4a9c2eece4e7f611b7523cef4400c31e3f80b6512669455d402251fb593d8d58fabfc5f5ba30f6cb9b556cd7813b801d346ff26660b76b9950a5a49f9fe8047b1022c24fbba9d7feb7c61bf83b57e7c6a8a6150f04fb83f6d3c51ec3023554135a169132f675f3ae2b61d72aeff22203199dd14801c7"),
120 Q: fromHex("9760508F15230BCCB292B982A2EB840BF0581CF5"),
121 G: fromHex("F7E1A085D69B3DDECBBCAB5C36B857B97994AFBBFA3AEA82F9574C0B3D0782675159578EBAD4594FE67107108180B449167123E84C281613B7CF09328CC8A6E13C167A8B547C8D28E0A3AE1E2BB3A675916EA37F0BFA213562F1FB627A01243BCCA4F1BEA8519089A883DFE15AE59F06928B665E807B552564014C3BFECF492A"),
122 },
123 },
124 X: fromHex("7D6E1A3DD4019FD809669D8AB8DA73807CEF7EC1"),
125 }
126 toBeSigned, err := NewSignedData(content)
127 if err != nil {
128 t.Fatalf("test case: cannot initialize signed data: %s", err)
129 }
130 if err := toBeSigned.SignWithoutAttr(signerCert, &priv, SignerInfoConfig{}); err != nil {
131 t.Fatalf("Cannot add signer: %s", err)
132 }
133 toBeSigned.Detach()
134 signed, err := toBeSigned.Finish()
135 if err != nil {
136 t.Fatalf("test case: cannot finish signing data: %s", err)
137 }
138
139 // write the signature to a temp file
140 tmpSignatureFile, err := ioutil.TempFile("", "TestDSASignAndVerifyWithOpenSSL_signature")
141 if err != nil {
142 t.Fatal(err)
143 }
144 ioutil.WriteFile(tmpSignatureFile.Name(), pem.EncodeToMemory(&pem.Block{Type: "PKCS7", Bytes: signed}), 0755)
145
146 // call openssl to verify the signature on the content using the root
147 opensslCMD := exec.Command("openssl", "smime", "-verify", "-noverify",
148 "-in", tmpSignatureFile.Name(), "-inform", "PEM",
149 "-content", tmpContentFile.Name())
150 out, err := opensslCMD.CombinedOutput()
151 if err != nil {
152 t.Fatalf("test case: openssl command failed with %s: %s", err, out)
153 }
154 os.Remove(tmpSignatureFile.Name()) // clean up
155 os.Remove(tmpContentFile.Name()) // clean up
156 os.Remove(tmpSignerCertFile.Name()) // clean up
157 }
158
159 func ExampleSignedData() {
160 // generate a signing cert or load a key pair
161 cert, err := createTestCertificate(x509.SHA256WithRSA)
162 if err != nil {
163 fmt.Printf("Cannot create test certificates: %s", err)
164 }
165
166 // Initialize a SignedData struct with content to be signed
167 signedData, err := NewSignedData([]byte("Example data to be signed"))
168 if err != nil {
169 fmt.Printf("Cannot initialize signed data: %s", err)
170 }
171
172 // Add the signing cert and private key
173 if err := signedData.AddSigner(cert.Certificate, cert.PrivateKey, SignerInfoConfig{}); err != nil {
174 fmt.Printf("Cannot add signer: %s", err)
175 }
176
177 // Call Detach() is you want to remove content from the signature
178 // and generate an S/MIME detached signature
179 signedData.Detach()
180
181 // Finish() to obtain the signature bytes
182 detachedSignature, err := signedData.Finish()
183 if err != nil {
184 fmt.Printf("Cannot finish signing data: %s", err)
185 }
186 pem.Encode(os.Stdout, &pem.Block{Type: "PKCS7", Bytes: detachedSignature})
187 }
188
189 func TestUnmarshalSignedAttribute(t *testing.T) {
190 cert, err := createTestCertificate(x509.SHA512WithRSA)
191 if err != nil {
192 t.Fatal(err)
193 }
194 content := []byte("Hello World")
195 toBeSigned, err := NewSignedData(content)
196 if err != nil {
197 t.Fatalf("Cannot initialize signed data: %s", err)
198 }
199 oidTest := asn1.ObjectIdentifier{2, 3, 4, 5, 6, 7}
200 testValue := "TestValue"
201 if err := toBeSigned.AddSigner(cert.Certificate, *cert.PrivateKey, SignerInfoConfig{
202 ExtraSignedAttributes: []Attribute{Attribute{Type: oidTest, Value: testValue}},
203 }); err != nil {
204 t.Fatalf("Cannot add signer: %s", err)
205 }
206 signed, err := toBeSigned.Finish()
207 if err != nil {
208 t.Fatalf("Cannot finish signing data: %s", err)
209 }
210 p7, err := Parse(signed)
211 if err != nil {
212 t.Fatalf("Cannot parse signed data: %v", err)
213 }
214 var actual string
215 err = p7.UnmarshalSignedAttribute(oidTest, &actual)
216 if err != nil {
217 t.Fatalf("Cannot unmarshal test value: %s", err)
218 }
219 if testValue != actual {
220 t.Errorf("Attribute does not match test value\n\tExpected: %s\n\tActual: %s", testValue, actual)
221 }
222 }
223
224 func TestDegenerateCertificate(t *testing.T) {
225 cert, err := createTestCertificate(x509.SHA1WithRSA)
226 if err != nil {
227 t.Fatal(err)
228 }
229 deg, err := DegenerateCertificate(cert.Certificate.Raw)
230 if err != nil {
231 t.Fatal(err)
232 }
233 testOpenSSLParse(t, deg)
234 pem.Encode(os.Stdout, &pem.Block{Type: "PKCS7", Bytes: deg})
235 }
236
237 // writes the cert to a temporary file and tests that openssl can read it.
238 func testOpenSSLParse(t *testing.T, certBytes []byte) {
239 tmpCertFile, err := ioutil.TempFile("", "testCertificate")
240 if err != nil {
241 t.Fatal(err)
242 }
243 defer os.Remove(tmpCertFile.Name()) // clean up
244
245 if _, err := tmpCertFile.Write(certBytes); err != nil {
246 t.Fatal(err)
247 }
248
249 opensslCMD := exec.Command("openssl", "pkcs7", "-inform", "der", "-in", tmpCertFile.Name())
250 _, err = opensslCMD.Output()
251 if err != nil {
252 t.Fatal(err)
253 }
254
255 if err := tmpCertFile.Close(); err != nil {
256 t.Fatal(err)
257 }
258
259 }
260 func fromHex(s string) *big.Int {
261 result, ok := new(big.Int).SetString(s, 16)
262 if !ok {
263 panic(s)
264 }
265 return result
266 }