| 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 |
} |