← Back to branch summary

~lynxman/ubuntu/precise/puppet/puppetlabsfixbug12844

« back to all changes in this revision

Viewing changes to test/certmgr/certmgr.rb

  • Committer: Bazaar Package Importer
  • Author(s): Marc Deslauriers
  • Date: 2011-10-24 15:05:12 UTC
  • Revision ID: james.westby@ubuntu.com-20111024150512-yxqwfdp6hcs6of5l
Tags: 2.7.1-1ubuntu3.2
* SECURITY UPDATE: puppet master impersonation via incorrect certificates
  - debian/patches/CVE-2011-3872.patch: refactor certificate handling.
  - Thanks to upstream for providing the patch.
  - CVE-2011-3872

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/certmgr/certmgr.rb
1
 
#!/usr/bin/env ruby
2
 
 
3
 
require File.expand_path(File.dirname(__FILE__) + '/../lib/puppettest')
4
 
 
5
 
require 'puppet'
6
 
require 'puppet/sslcertificates.rb'
7
 
require 'puppettest'
8
 
require 'puppettest/certificates'
9
 
require 'mocha'
10
 
 
11
 
class TestCertMgr < Test::Unit::TestCase
12
 
  include PuppetTest::Certificates
13
 
  def setup
14
 
    super
15
 
    #@dir = File.join(Puppet[:certdir], "testing")
16
 
    @dir = File.join(@configpath, "certest")
17
 
    system("mkdir -p #{@dir}")
18
 
 
19
 
    Puppet::Util::SUIDManager.stubs(:asuser).yields
20
 
  end
21
 
 
22
 
  def testCreateSelfSignedCertificate
23
 
    cert = nil
24
 
    name = "testing"
25
 
    newcert = proc {
26
 
 
27
 
            Puppet::SSLCertificates::Certificate.new(
28
 
                
29
 
        :name => name,
30
 
        
31
 
        :selfsign => true
32
 
      )
33
 
    }
34
 
    assert_nothing_raised {
35
 
      cert = newcert.call
36
 
    }
37
 
    assert_nothing_raised {
38
 
      cert.mkselfsigned
39
 
    }
40
 
 
41
 
    assert_raise(Puppet::Error) {
42
 
      cert.mkselfsigned
43
 
    }
44
 
 
45
 
    assert_nothing_raised {
46
 
      cert.write
47
 
    }
48
 
 
49
 
    assert(FileTest.exists?(cert.certfile))
50
 
 
51
 
    assert_nothing_raised {
52
 
      cert.delete
53
 
    }
54
 
 
55
 
    assert_nothing_raised {
56
 
      cert = newcert.call
57
 
    }
58
 
    assert_nothing_raised {
59
 
      cert.mkselfsigned
60
 
    }
61
 
 
62
 
    assert_nothing_raised {
63
 
      cert.delete
64
 
    }
65
 
 
66
 
  end
67
 
 
68
 
  def disabled_testCreateEncryptedSelfSignedCertificate
69
 
    cert = nil
70
 
    name = "testing"
71
 
    keyfile = mkPassFile
72
 
    assert_nothing_raised {
73
 
 
74
 
            cert = Puppet::SSLCertificates::Certificate.new(
75
 
                
76
 
        :name => name,
77
 
        :selfsign => true,
78
 
        
79
 
        :capass => keyfile
80
 
      )
81
 
    }
82
 
    assert_nothing_raised {
83
 
      cert.mkselfsigned
84
 
    }
85
 
    assert_nothing_raised {
86
 
      cert.mkhash
87
 
    }
88
 
 
89
 
    assert_raise(Puppet::Error) {
90
 
      cert.mkselfsigned
91
 
    }
92
 
 
93
 
    assert(FileTest.exists?(cert.certfile))
94
 
    assert(FileTest.exists?(cert.hash))
95
 
 
96
 
    assert_nothing_raised {
97
 
      cert.delete
98
 
    }
99
 
 
100
 
    assert_nothing_raised {
101
 
      cert.mkselfsigned
102
 
    }
103
 
 
104
 
    assert_nothing_raised {
105
 
      cert.delete
106
 
    }
107
 
 
108
 
  end
109
 
 
110
 
  def testCreateCA
111
 
    ca = nil
112
 
    assert_nothing_raised {
113
 
      ca = Puppet::SSLCertificates::CA.new
114
 
    }
115
 
 
116
 
    # make the CA again and verify it doesn't fail because everything
117
 
    # still exists
118
 
    assert_nothing_raised {
119
 
      ca = Puppet::SSLCertificates::CA.new
120
 
    }
121
 
 
122
 
  end
123
 
 
124
 
  def testSignCert
125
 
    ca = mkCA()
126
 
 
127
 
    cert = nil
128
 
    assert_nothing_raised {
129
 
 
130
 
            cert = Puppet::SSLCertificates::Certificate.new(
131
 
                
132
 
        :name => "signedcertest",
133
 
        :property => "TN",
134
 
        :city => "Nashville",
135
 
        :country => "US",
136
 
        :email => "luke@madstop.com",
137
 
        :org => "Puppet",
138
 
        :ou => "Development",
139
 
        
140
 
        :encrypt => mkPassFile()
141
 
      )
142
 
 
143
 
    }
144
 
 
145
 
    assert_nothing_raised {
146
 
      cert.mkcsr
147
 
    }
148
 
 
149
 
    signedcert = nil
150
 
    cacert = nil
151
 
 
152
 
    assert_nothing_raised {
153
 
      signedcert, cacert = ca.sign(cert.csr)
154
 
    }
155
 
 
156
 
    assert_instance_of(OpenSSL::X509::Certificate, signedcert)
157
 
    assert_instance_of(OpenSSL::X509::Certificate, cacert)
158
 
 
159
 
    assert_nothing_raised {
160
 
      cert.cert = signedcert
161
 
      cert.cacert = cacert
162
 
      cert.write
163
 
    }
164
 
    #system("find #{Puppet[:ssldir]}")
165
 
    #system("cp -R #{Puppet[:ssldir]} /tmp/ssltesting")
166
 
 
167
 
    output = nil
168
 
    assert_nothing_raised {
169
 
      output = %x{openssl verify -CAfile #{Puppet[:cacert]} -purpose sslserver #{cert.certfile}}
170
 
      #output = %x{openssl verify -CApath #{Puppet[:certdir]} -purpose sslserver #{cert.certfile}}
171
 
    }
172
 
 
173
 
    assert_equal($CHILD_STATUS,0)
174
 
    assert_equal(File.join(Puppet[:certdir], "signedcertest.pem: OK\n"), output)
175
 
  end
176
 
 
177
 
 
178
 
  def test_interactiveca
179
 
    ca = nil
180
 
 
181
 
    assert_nothing_raised {
182
 
      ca = Puppet::SSLCertificates::CA.new
183
 
    }
184
 
 
185
 
    # basic initialization
186
 
    hostname = "test.hostname.com"
187
 
    cert = mkcert(hostname)
188
 
 
189
 
    # create the csr
190
 
    csr = nil
191
 
    assert_nothing_raised {
192
 
      csr = cert.mkcsr
193
 
    }
194
 
 
195
 
    assert_nothing_raised {
196
 
      ca.storeclientcsr(csr)
197
 
    }
198
 
 
199
 
    # store it
200
 
    pulledcsr = nil
201
 
    assert_nothing_raised {
202
 
      pulledcsr = ca.getclientcsr(hostname)
203
 
    }
204
 
 
205
 
    assert_equal(csr.to_pem, pulledcsr.to_pem)
206
 
 
207
 
    signedcert = nil
208
 
    assert_nothing_raised {
209
 
      signedcert, cacert = ca.sign(csr)
210
 
    }
211
 
 
212
 
    assert_instance_of(OpenSSL::X509::Certificate, signedcert)
213
 
    newsignedcert = nil
214
 
    assert_nothing_raised {
215
 
      newsignedcert, cacert = ca.getclientcert(hostname)
216
 
    }
217
 
 
218
 
    assert(newsignedcert)
219
 
 
220
 
    assert_equal(signedcert.to_pem, newsignedcert.to_pem)
221
 
  end
222
 
 
223
 
  def test_cafailures
224
 
    ca = mkCA()
225
 
    cert = cacert = nil
226
 
    assert_nothing_raised {
227
 
      cert, cacert = ca.getclientcert("nohost")
228
 
    }
229
 
    assert_nil(cert)
230
 
  end
231
 
 
232
 
  def test_crl
233
 
    ca = mkCA()
234
 
    h1 = mksignedcert(ca, "host1.example.com")
235
 
    h2 = mksignedcert(ca, "host2.example.com")
236
 
 
237
 
    assert(ca.cert.verify(ca.cert.public_key))
238
 
    assert(h1.verify(ca.cert.public_key))
239
 
    assert(h2.verify(ca.cert.public_key))
240
 
 
241
 
    crl = ca.crl
242
 
    assert_not_nil(crl)
243
 
 
244
 
    store = mkStore(ca)
245
 
    assert( store.verify(ca.cert))
246
 
    assert( store.verify(h1, [ca.cert]))
247
 
    assert( store.verify(h2, [ca.cert]))
248
 
 
249
 
    ca.revoke(h1.serial)
250
 
 
251
 
    oldcert = File.read(Puppet.settings[:cacert])
252
 
    oldserial = File.read(Puppet.settings[:serial])
253
 
 
254
 
    # Recreate the CA from disk
255
 
    ca = mkCA()
256
 
    newcert = File.read(Puppet.settings[:cacert])
257
 
    newserial = File.read(Puppet.settings[:serial])
258
 
    assert_equal(oldcert, newcert, "The certs are not equal after making a new CA.")
259
 
    assert_equal(oldserial, newserial, "The serials are not equal after making a new CA.")
260
 
    store = mkStore(ca)
261
 
    assert( store.verify(ca.cert), "Could not verify CA certs after reloading certs.")
262
 
    assert(!store.verify(h1, [ca.cert]), "Incorrectly verified revoked cert.")
263
 
    assert( store.verify(h2, [ca.cert]), "Could not verify certs with reloaded CA.")
264
 
 
265
 
    ca.revoke(h2.serial)
266
 
    assert_equal(1, ca.crl.extensions.size)
267
 
 
268
 
    # Recreate the CA from disk
269
 
    ca = mkCA()
270
 
    store = mkStore(ca)
271
 
    assert( store.verify(ca.cert))
272
 
    assert(!store.verify(h1, [ca.cert]), "first revoked cert passed")
273
 
    assert(!store.verify(h2, [ca.cert]), "second revoked cert passed")
274
 
  end
275
 
 
276
 
  def test_ttl
277
 
    cert = mksignedcert
278
 
    assert_equal(5 * 365 * 24 * 60 * 60,  cert.not_after - cert.not_before)
279
 
 
280
 
    Puppet[:ca_ttl] = 7 * 24 * 60 * 60
281
 
    cert = mksignedcert
282
 
    assert_equal(7 * 24 * 60 * 60,  cert.not_after - cert.not_before)
283
 
 
284
 
    Puppet[:ca_ttl] = "2y"
285
 
    cert = mksignedcert
286
 
    assert_equal(2 * 365 * 24 * 60 * 60,  cert.not_after - cert.not_before)
287
 
 
288
 
    Puppet[:ca_ttl] = "2y"
289
 
    cert = mksignedcert
290
 
    assert_equal(2 * 365 * 24 * 60 * 60,  cert.not_after - cert.not_before)
291
 
 
292
 
    Puppet[:ca_ttl] = "1h"
293
 
    cert = mksignedcert
294
 
    assert_equal(60 * 60,  cert.not_after - cert.not_before)
295
 
 
296
 
    Puppet[:ca_ttl] = "900s"
297
 
    cert = mksignedcert
298
 
    assert_equal(900,  cert.not_after - cert.not_before)
299
 
 
300
 
    # This needs to be last, to make sure that setting ca_days
301
 
    # overrides setting ca_ttl
302
 
    Puppet[:ca_days] = 3
303
 
    cert = mksignedcert
304
 
    assert_equal(3 * 24 * 60 * 60,  cert.not_after - cert.not_before)
305
 
 
306
 
  end
307
 
end
308