diff --git a/.github/workflows/cov.yaml b/.github/workflows/cov.yaml index 8375b58d36..7f49bc81be 100644 --- a/.github/workflows/cov.yaml +++ b/.github/workflows/cov.yaml @@ -43,7 +43,7 @@ jobs: - name: Coveralls # Use commit hash here to avoid a re-tagging attack, as this is a third-party action # Commit 3dfc5567390f6fa9267c0ee9c251e4c8c3f18949 = tag v2 - uses: coverallsapp/github-action@3dfc5567390f6fa9267c0ee9c251e4c8c3f18949 + uses: coverallsapp/github-action@643bc377ffa44ace6394b2b5d0d3950076de9f63 with: github-token: ${{ secrets.github_token }} file: src/github.com/nats-io/nats-server/coverage.lcov diff --git a/.travis.yml b/.travis.yml index cb32ceb1e0..ecc2c29e6a 100644 --- a/.travis.yml +++ b/.travis.yml @@ -8,7 +8,7 @@ language: go go: # This should be quoted or use .x, but should not be unquoted. # Remember that a YAML bare float drops trailing zeroes. - - "1.22.6" + - "1.22.7" - "1.21.13" go_import_path: github.com/nats-io/nats-server diff --git a/go.mod b/go.mod index 7c235cf201..f9a0b5ed0b 100644 --- a/go.mod +++ b/go.mod @@ -10,7 +10,7 @@ require ( github.com/nats-io/nkeys v0.4.7 github.com/nats-io/nuid v1.0.1 go.uber.org/automaxprocs v1.5.3 - golang.org/x/crypto v0.26.0 - golang.org/x/sys v0.24.0 + golang.org/x/crypto v0.27.0 + golang.org/x/sys v0.25.0 golang.org/x/time v0.6.0 ) diff --git a/go.sum b/go.sum index e678c00945..fe5935a31e 100644 --- a/go.sum +++ b/go.sum @@ -20,19 +20,11 @@ github.com/stretchr/testify v1.7.1 h1:5TQK59W5E3v0r2duFAb7P95B6hEeOyEnHRa8MjYSMT github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= go.uber.org/automaxprocs v1.5.3 h1:kWazyxZUrS3Gs4qUpbwo5kEIMGe/DAvi5Z4tl2NW4j8= go.uber.org/automaxprocs v1.5.3/go.mod h1:eRbA25aqJrxAbsLO0xy5jVwPt7FQnRgjW+efnwa1WM0= -golang.org/x/crypto v0.25.0 h1:ypSNr+bnYL2YhwoMt2zPxHFmbAN1KZs/njMG3hxUp30= -golang.org/x/crypto v0.25.0/go.mod h1:T+wALwcMOSE0kXgUAnPAHqTLW+XHgcELELW8VaDgm/M= -golang.org/x/crypto v0.26.0 h1:RrRspgV4mU+YwB4FYnuBoKsUapNIL5cohGAmSH3azsw= -golang.org/x/crypto v0.26.0/go.mod h1:GY7jblb9wI+FOo5y8/S2oY4zWP07AkOJ4+jxCqdqn54= +golang.org/x/crypto v0.27.0 h1:GXm2NjJrPaiv/h1tb2UH8QfgC/hOf/+z0p6PT8o1w7A= +golang.org/x/crypto v0.27.0/go.mod h1:1Xngt8kV6Dvbssa53Ziq6Eqn0HqbZi5Z6R0ZpwQzt70= golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/sys v0.22.0 h1:RI27ohtqKCnwULzJLqkv897zojh5/DwS/ENaMzUOaWI= -golang.org/x/sys v0.22.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/sys v0.23.0 h1:YfKFowiIMvtgl1UERQoTPPToxltDeZfbj4H7dVUCwmM= -golang.org/x/sys v0.23.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/sys v0.24.0 h1:Twjiwq9dn6R1fQcyiK+wQyHWfaz/BJB+YIpzU/Cv3Xg= -golang.org/x/sys v0.24.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk= -golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= +golang.org/x/sys v0.25.0 h1:r+8e+loiHxRqhXVl6ML1nO3l1+oFoWbnlu2Ehimmi34= +golang.org/x/sys v0.25.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/time v0.6.0 h1:eTDhh4ZXt5Qf0augr54TN6suAUudPcawVZeIAPU7D4U= golang.org/x/time v0.6.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= diff --git a/server/auth.go b/server/auth.go index 0a9564f4d0..5a1a4acd54 100644 --- a/server/auth.go +++ b/server/auth.go @@ -872,7 +872,10 @@ func (s *Server) processClientOrLeafAuthentication(c *client, opts *Options) (au c.Debugf("Account JWT lookup error: %v", err) return false } - if !s.isTrustedIssuer(acc.Issuer) { + acc.mu.RLock() + aissuer := acc.Issuer + acc.mu.RUnlock() + if !s.isTrustedIssuer(aissuer) { c.Debugf("Account JWT not signed by trusted operator") return false } diff --git a/server/filestore.go b/server/filestore.go index 16d3ef05d4..c6372ed527 100644 --- a/server/filestore.go +++ b/server/filestore.go @@ -436,6 +436,9 @@ func newFileStoreWithCreated(fcfg FileStoreConfig, cfg StreamConfig, created tim // Attempt to recover our state. err = fs.recoverFullState() if err != nil { + if !os.IsNotExist(err) { + fs.warn("Recovering stream state from index errored: %v", err) + } // Hold onto state prior := fs.state // Reset anything that could have been set from above. @@ -469,7 +472,7 @@ func newFileStoreWithCreated(fcfg FileStoreConfig, cfg StreamConfig, created tim go fs.cleanupOldMeta() }() - // Lock while do enforcements and removals. + // Lock while we do enforcements and removals. fs.mu.Lock() // Check if we have any left over tombstones to process. @@ -975,7 +978,6 @@ func (mb *msgBlock) ensureLastChecksumLoaded() { // Lock held on entry func (fs *fileStore) recoverMsgBlock(index uint32) (*msgBlock, error) { mb := fs.initMsgBlock(index) - // Open up the message file, but we will try to recover from the index file. // We will check that the last checksums match. file, err := mb.openBlock() @@ -1357,6 +1359,9 @@ func (mb *msgBlock) rebuildStateLocked() (*LostStreamData, []uint64, error) { minTombstoneTs int64 ) + // To detect gaps from compaction. + var last uint64 + for index, lbuf := uint32(0), uint32(len(buf)); index < lbuf; { if index+msgHdrSize > lbuf { truncate(index) @@ -1444,8 +1449,16 @@ func (mb *msgBlock) rebuildStateLocked() (*LostStreamData, []uint64, error) { mb.bytes += uint64(rl) } + // Check for any gaps from compaction, meaning no ebit entry. + if last > 0 && seq != last+1 { + for dseq := last + 1; dseq < seq; dseq++ { + addToDmap(dseq) + } + } + // Always set last - atomic.StoreUint64(&mb.last.seq, seq) + last = seq + atomic.StoreUint64(&mb.last.seq, last) mb.last.ts = ts // Advance to next record. @@ -1665,7 +1678,8 @@ func (fs *fileStore) recoverFullState() (rerr error) { for i := 0; i < int(numBlocks); i++ { index, nbytes, fseq, fts, lseq, lts, numDeleted := uint32(readU64()), readU64(), readU64(), readI64(), readU64(), readI64(), readU64() if bi < 0 { - break + os.Remove(fn) + return errCorruptState } mb := fs.initMsgBlock(index) atomic.StoreUint64(&mb.first.seq, fseq) @@ -1734,6 +1748,12 @@ func (fs *fileStore) recoverFullState() (rerr error) { return errPriorState } if matched = bytes.Equal(mb.lastChecksum(), lchk[:]); !matched { + // If we are tracking max msgs per subject and we are not up to date we should rebuild. + if fs.cfg.MaxMsgsPer > 0 { + fs.warn("Stream state block state outdated, will rebuild") + return errPriorState + } + // Remove the last message block since recover will add in the new one. fs.removeMsgBlockFromList(mb) // Reverse update of tracking state for this mb, will add new state in below. @@ -1776,11 +1796,19 @@ func (fs *fileStore) recoverFullState() (rerr error) { // Update top level accounting if fseq := atomic.LoadUint64(&nmb.first.seq); fs.state.FirstSeq == 0 || fseq < fs.state.FirstSeq { fs.state.FirstSeq = fseq - fs.state.FirstTime = time.Unix(0, nmb.first.ts).UTC() + if nmb.first.ts == 0 { + fs.state.FirstTime = time.Time{} + } else { + fs.state.FirstTime = time.Unix(0, nmb.first.ts).UTC() + } } if lseq := atomic.LoadUint64(&nmb.last.seq); lseq > fs.state.LastSeq { fs.state.LastSeq = lseq - fs.state.LastTime = time.Unix(0, nmb.last.ts).UTC() + if mb.last.ts == 0 { + fs.state.LastTime = time.Time{} + } else { + fs.state.LastTime = time.Unix(0, nmb.last.ts).UTC() + } } fs.state.Msgs += nmb.msgs fs.state.Bytes += nmb.bytes @@ -5302,7 +5330,8 @@ func (mb *msgBlock) ensureRawBytesLoaded() error { // Sync msg and index files as needed. This is called from a timer. func (fs *fileStore) syncBlocks() { fs.mu.RLock() - if fs.closed { + // If closed or a snapshot is in progress bail. + if fs.closed || fs.sips > 0 { fs.mu.RUnlock() return } @@ -6786,6 +6815,7 @@ func (fs *fileStore) PurgeEx(subject string, sequence, keep uint64) (purged uint } var smv StoreMsg + var tombs []msgId fs.mu.Lock() // We may remove blocks as we purge, so don't range directly on fs.blks @@ -6839,9 +6869,11 @@ func (fs *fileStore) PurgeEx(subject string, sequence, keep uint64) (purged uint purged++ bytes += rl } - // FSS updates. + // PSIM and FSS updates. mb.removeSeqPerSubject(sm.subj, seq) fs.removePerSubject(sm.subj) + // Track tombstones we need to write. + tombs = append(tombs, msgId{sm.seq, sm.ts}) // Check for first message. if seq == atomic.LoadUint64(&mb.first.seq) { @@ -6880,7 +6912,16 @@ func (fs *fileStore) PurgeEx(subject string, sequence, keep uint64) (purged uint if firstSeqNeedsUpdate { fs.selectNextFirst() } + fseq := fs.state.FirstSeq + + // Write any tombstones as needed. + for _, tomb := range tombs { + if tomb.seq > fseq { + fs.lmb.writeTombstone(tomb.seq, tomb.ts) + } + } + os.Remove(filepath.Join(fs.fcfg.StoreDir, msgDir, streamStreamStateFile)) fs.dirty++ cb := fs.scb fs.mu.Unlock() @@ -6923,7 +6964,7 @@ func (fs *fileStore) purge(fseq uint64) (uint64, error) { fs.bim = make(map[uint32]*msgBlock) // Clear any per subject tracking. fs.psim, fs.tsl = fs.psim.Empty(), 0 - // Mark dirty + // Mark dirty. fs.dirty++ // Move the msgs directory out of the way, will delete out of band. @@ -6979,6 +7020,11 @@ func (fs *fileStore) purge(fseq uint64) (uint64, error) { cb := fs.scb fs.mu.Unlock() + // Force a new index.db to be written. + if purged > 0 { + fs.forceWriteFullState() + } + if cb != nil { cb(-int64(purged), -rbytes, 0, _EMPTY_) } @@ -7173,11 +7219,19 @@ SKIP: } fs.state.Bytes -= bytes + // Any existing state file no longer applicable. We will force write a new one + // after we release the lock. + os.Remove(filepath.Join(fs.fcfg.StoreDir, msgDir, streamStreamStateFile)) fs.dirty++ cb := fs.scb fs.mu.Unlock() + // Force a new index.db to be written. + if purged > 0 { + fs.forceWriteFullState() + } + if cb != nil && purged > 0 { cb(-int64(purged), -int64(bytes), 0, _EMPTY_) } @@ -7238,6 +7292,40 @@ func (fs *fileStore) reset() error { return nil } +// Return all active tombstones in this msgBlock. +// Write lock should be held. +func (mb *msgBlock) tombs() []msgId { + var tombs []msgId + + if !mb.cacheAlreadyLoaded() { + if err := mb.loadMsgsWithLock(); err != nil { + return nil + } + } + + var le = binary.LittleEndian + buf := mb.cache.buf + + for index, lbuf := uint32(0), uint32(len(buf)); index < lbuf; { + if index+msgHdrSize > lbuf { + return tombs + } + hdr := buf[index : index+msgHdrSize] + rl, seq := le.Uint32(hdr[0:]), le.Uint64(hdr[4:]) + // Clear any headers bit that could be set. + rl &^= hbit + // Check for tombstones. + if seq&tbit != 0 { + ts := int64(le.Uint64(hdr[12:])) + tombs = append(tombs, msgId{seq &^ tbit, ts}) + } + // Advance to next record. + index += rl + } + + return tombs +} + // Truncate will truncate a stream store up to seq. Sequence needs to be valid. func (fs *fileStore) Truncate(seq uint64) error { // Check for request to reset. @@ -7273,6 +7361,10 @@ func (fs *fileStore) Truncate(seq uint64) error { fs.mu.Unlock() return err } + // Collect all tombstones, we want to put these back so we can survive + // a restore without index.db properly. + var tombs []msgId + tombs = append(tombs, nlmb.tombs()...) var purged, bytes uint64 @@ -7290,6 +7382,8 @@ func (fs *fileStore) Truncate(seq uint64) error { getLastMsgBlock := func() *msgBlock { return fs.blks[len(fs.blks)-1] } for mb := getLastMsgBlock(); mb != nlmb; mb = getLastMsgBlock() { mb.mu.Lock() + // We do this to load tombs. + tombs = append(tombs, mb.tombs()...) purged += mb.msgs bytes += mb.bytes fs.removeMsgBlock(mb) @@ -7312,11 +7406,29 @@ func (fs *fileStore) Truncate(seq uint64) error { // Reset our subject lookup info. fs.resetGlobalPerSubjectInfo() + // Always create new write block. + fs.newMsgBlockForWrite() + + // Write any tombstones as needed. + for _, tomb := range tombs { + if tomb.seq <= lsm.seq { + fs.lmb.writeTombstone(tomb.seq, tomb.ts) + } + } + + // Any existing state file no longer applicable. We will force write a new one + // after we release the lock. + os.Remove(filepath.Join(fs.fcfg.StoreDir, msgDir, streamStreamStateFile)) fs.dirty++ cb := fs.scb fs.mu.Unlock() + // Force a new index.db to be written. + if purged > 0 { + fs.forceWriteFullState() + } + if cb != nil { cb(-int64(purged), -int64(bytes), 0, _EMPTY_) } @@ -8138,26 +8250,6 @@ func (fs *fileStore) streamSnapshot(w io.WriteCloser, includeConsumers bool) { msgPre := msgDir + "/" var bbuf []byte - const minLen = 32 - sfn := filepath.Join(fs.fcfg.StoreDir, msgDir, streamStreamStateFile) - if buf, err := os.ReadFile(sfn); err == nil && len(buf) >= minLen { - if fs.aek != nil { - ns := fs.aek.NonceSize() - buf, err = fs.aek.Open(nil, buf[:ns], buf[ns:len(buf)-highwayhash.Size64], nil) - if err == nil { - // Redo hash checksum at end on plaintext. - fs.mu.Lock() - hh.Reset() - hh.Write(buf) - buf = fs.hh.Sum(buf) - fs.mu.Unlock() - } - } - if err == nil && writeFile(msgPre+streamStreamStateFile, buf) != nil { - return - } - } - // Now do messages themselves. for _, mb := range blks { if mb.pendingWriteSize() > 0 { @@ -8196,6 +8288,30 @@ func (fs *fileStore) streamSnapshot(w io.WriteCloser, includeConsumers bool) { } } + // Do index.db last. We will force a write as well. + // Write out full state as well before proceeding. + if err := fs.forceWriteFullState(); err == nil { + const minLen = 32 + sfn := filepath.Join(fs.fcfg.StoreDir, msgDir, streamStreamStateFile) + if buf, err := os.ReadFile(sfn); err == nil && len(buf) >= minLen { + if fs.aek != nil { + ns := fs.aek.NonceSize() + buf, err = fs.aek.Open(nil, buf[:ns], buf[ns:len(buf)-highwayhash.Size64], nil) + if err == nil { + // Redo hash checksum at end on plaintext. + fs.mu.Lock() + hh.Reset() + hh.Write(buf) + buf = fs.hh.Sum(buf) + fs.mu.Unlock() + } + } + if err == nil && writeFile(msgPre+streamStreamStateFile, buf) != nil { + return + } + } + } + // Bail if no consumers requested. if !includeConsumers { return @@ -8268,9 +8384,6 @@ func (fs *fileStore) Snapshot(deadline time.Duration, checkMsgs, includeConsumer } } - // Write out full state as well before proceeding. - fs.writeFullState() - pr, pw := net.Pipe() // Set a write deadline here to protect ourselves. diff --git a/server/filestore_test.go b/server/filestore_test.go index 2d4891f72e..cb5737cec2 100644 --- a/server/filestore_test.go +++ b/server/filestore_test.go @@ -1051,6 +1051,19 @@ func TestFileStoreStreamTruncate(t *testing.T) { mb := fs.getFirstBlock() require_True(t, mb != nil) require_NoError(t, mb.loadMsgs()) + + // Also make sure we can recover properly with no index.db present. + // We want to make sure we preserve tombstones from any blocks being deleted. + fs.Stop() + os.Remove(filepath.Join(fs.fcfg.StoreDir, msgDir, streamStreamStateFile)) + + fs, err = newFileStoreWithCreated(fcfg, cfg, created, prf(&fcfg), nil) + require_NoError(t, err) + defer fs.Stop() + + if state := fs.State(); !reflect.DeepEqual(state, before) { + t.Fatalf("Expected state of %+v, got %+v without index.db state", before, state) + } }) } @@ -3635,11 +3648,16 @@ func TestFileStorePurgeExWithSubject(t *testing.T) { testFileStoreAllPermutations(t, func(t *testing.T, fcfg FileStoreConfig) { fcfg.BlockSize = 1000 cfg := StreamConfig{Name: "TEST", Subjects: []string{"foo.>"}, Storage: FileStorage} - fs, err := newFileStoreWithCreated(fcfg, cfg, time.Now(), prf(&fcfg), nil) + created := time.Now() + fs, err := newFileStoreWithCreated(fcfg, cfg, created, prf(&fcfg), nil) require_NoError(t, err) defer fs.Stop() payload := make([]byte, 20) + + _, _, err = fs.StoreMsg("foo.0", nil, payload) + require_NoError(t, err) + total := 200 for i := 0; i < total; i++ { _, _, err = fs.StoreMsg("foo.1", nil, payload) @@ -3648,13 +3666,38 @@ func TestFileStorePurgeExWithSubject(t *testing.T) { _, _, err = fs.StoreMsg("foo.2", nil, []byte("xxxxxx")) require_NoError(t, err) - // This should purge all. + // This should purge all "foo.1" p, err := fs.PurgeEx("foo.1", 1, 0) require_NoError(t, err) - require_True(t, int(p) == total) - require_True(t, int(p) == total) - require_True(t, fs.State().Msgs == 1) - require_True(t, fs.State().FirstSeq == 201) + require_Equal(t, p, uint64(total)) + + state := fs.State() + require_Equal(t, state.Msgs, 2) + require_Equal(t, state.FirstSeq, 1) + + // Make sure we can recover same state. + fs.Stop() + fs, err = newFileStoreWithCreated(fcfg, cfg, created, prf(&fcfg), nil) + require_NoError(t, err) + defer fs.Stop() + + before := state + if state := fs.State(); !reflect.DeepEqual(state, before) { + t.Fatalf("Expected state of %+v, got %+v", before, state) + } + + // Also make sure we can recover properly with no index.db present. + // We want to make sure we preserve any tombstones from the subject based purge. + fs.Stop() + os.Remove(filepath.Join(fs.fcfg.StoreDir, msgDir, streamStreamStateFile)) + + fs, err = newFileStoreWithCreated(fcfg, cfg, created, prf(&fcfg), nil) + require_NoError(t, err) + defer fs.Stop() + + if state := fs.State(); !reflect.DeepEqual(state, before) { + t.Fatalf("Expected state of %+v, got %+v without index.db state", before, state) + } }) } @@ -7456,6 +7499,47 @@ func TestFileStoreSyncCompressOnlyIfDirty(t *testing.T) { require_False(t, noCompact) } +// This test is for deleted interior message tracking after compaction from limits based deletes, meaning no tombstones. +// Bug was that dmap would not be properly be hydrated after the compact from rebuild. But we did so in populateGlobalInfo. +// So this is just to fix a bug in rebuildState tracking gaps after a compact. +func TestFileStoreDmapBlockRecoverAfterCompact(t *testing.T) { + sd := t.TempDir() + fs, err := newFileStore( + FileStoreConfig{StoreDir: sd, BlockSize: 256}, + StreamConfig{Name: "zzz", Subjects: []string{"foo.*"}, Storage: FileStorage, MaxMsgsPer: 1}) + require_NoError(t, err) + defer fs.Stop() + + msg := []byte("hello") + + // 6 msgs per block. + // Fill the first block. + for i := 1; i <= 6; i++ { + fs.StoreMsg(fmt.Sprintf("foo.%d", i), nil, msg) + } + require_Equal(t, fs.numMsgBlocks(), 1) + + // Now create holes in the first block via the max msgs per subject of 1. + for i := 2; i < 6; i++ { + fs.StoreMsg(fmt.Sprintf("foo.%d", i), nil, msg) + } + require_Equal(t, fs.numMsgBlocks(), 2) + // Compact and rebuild the first blk. Do not have it call indexCacheBuf which will fix it up. + mb := fs.getFirstBlock() + mb.mu.Lock() + mb.compact() + // Empty out dmap state. + mb.dmap.Empty() + ld, tombs, err := mb.rebuildStateLocked() + dmap := mb.dmap.Clone() + mb.mu.Unlock() + + require_NoError(t, err) + require_Equal(t, ld, nil) + require_Equal(t, len(tombs), 0) + require_Equal(t, dmap.Size(), 4) +} + /////////////////////////////////////////////////////////////////////////// // Benchmarks /////////////////////////////////////////////////////////////////////////// diff --git a/server/jetstream_cluster.go b/server/jetstream_cluster.go index 18a67c32e9..14af031ea4 100644 --- a/server/jetstream_cluster.go +++ b/server/jetstream_cluster.go @@ -3792,7 +3792,8 @@ func (js *jetStream) processClusterCreateStream(acc *Account, sa *streamAssignme } mset.setStreamAssignment(sa) // Check if our config has really been updated. - if !reflect.DeepEqual(mset.config(), sa.Config) { + cfg := mset.config() + if !reflect.DeepEqual(&cfg, sa.Config) { if err = mset.updateWithAdvisory(sa.Config, false); err != nil { s.Warnf("JetStream cluster error updating stream %q for account %q: %v", sa.Config.Name, acc.Name, err) if osa != nil { diff --git a/server/jetstream_cluster_3_test.go b/server/jetstream_cluster_3_test.go index e3b2c4007f..82c928440e 100644 --- a/server/jetstream_cluster_3_test.go +++ b/server/jetstream_cluster_3_test.go @@ -2954,11 +2954,12 @@ func TestJetStreamClusterStreamMaxAgeScaleUp(t *testing.T) { Storage: test.storage, }) require_NoError(t, err) + c.waitOnStreamLeader(globalAccountName, test.stream) // All messages should still be there. info, err := js.StreamInfo(test.stream) require_NoError(t, err) - require_True(t, info.State.Msgs == 10) + require_Equal(t, info.State.Msgs, 10) // Wait until MaxAge is reached. time.Sleep(ttl - time.Since(start) + (1 * time.Second)) @@ -2966,17 +2967,17 @@ func TestJetStreamClusterStreamMaxAgeScaleUp(t *testing.T) { // Check if all messages are expired. info, err = js.StreamInfo(test.stream) require_NoError(t, err) - require_True(t, info.State.Msgs == 0) + require_Equal(t, info.State.Msgs, 0) // Now switch leader to one of replicas _, err = nc.Request(fmt.Sprintf(JSApiStreamLeaderStepDownT, test.stream), nil, time.Second) require_NoError(t, err) - c.waitOnStreamLeader("$G", test.stream) + c.waitOnStreamLeader(globalAccountName, test.stream) // and make sure that it also expired all messages info, err = js.StreamInfo(test.stream) require_NoError(t, err) - require_True(t, info.State.Msgs == 0) + require_Equal(t, info.State.Msgs, 0) }) } } diff --git a/server/jetstream_cluster_4_test.go b/server/jetstream_cluster_4_test.go index a9331472c4..592a0e0148 100644 --- a/server/jetstream_cluster_4_test.go +++ b/server/jetstream_cluster_4_test.go @@ -2936,3 +2936,512 @@ func TestJetStreamClusterKeyValueLastSeqMismatch(t *testing.T) { }) } } + +func TestJetStreamClusterPubAckSequenceDupe(t *testing.T) { + c := createJetStreamClusterExplicit(t, "TEST_CLUSTER", 3) + defer c.shutdown() + + nc, js := jsClientConnect(t, c.randomServer()) + defer nc.Close() + + type client struct { + nc *nats.Conn + js nats.JetStreamContext + } + + clients := make([]client, len(c.servers)) + for i, server := range c.servers { + clients[i].nc, clients[i].js = jsClientConnect(t, server) + defer clients[i].nc.Close() + } + + _, err := js.AddStream(&nats.StreamConfig{ + Name: "TEST_STREAM", + Subjects: []string{"TEST_SUBJECT.*"}, + Replicas: 3, + Duplicates: 1 * time.Minute, + }) + require_NoError(t, err) + + msgData := []byte("...") + + for seq := uint64(1); seq < 10; seq++ { + + if seq%3 == 0 { + c.restartAll() + } + + msgSubject := "TEST_SUBJECT." + strconv.FormatUint(seq, 10) + msgIdOpt := nats.MsgId(nuid.Next()) + + firstPublisherClient := &clients[rand.Intn(len(clients))] + secondPublisherClient := &clients[rand.Intn(len(clients))] + + pubAck1, err := firstPublisherClient.js.Publish(msgSubject, msgData, msgIdOpt) + require_NoError(t, err) + require_Equal(t, seq, pubAck1.Sequence) + require_False(t, pubAck1.Duplicate) + + pubAck2, err := secondPublisherClient.js.Publish(msgSubject, msgData, msgIdOpt) + require_NoError(t, err) + require_Equal(t, seq, pubAck2.Sequence) + require_True(t, pubAck2.Duplicate) + + } + +} + +func TestJetStreamClusterConsumeWithStartSequence(t *testing.T) { + + const ( + NumMessages = 10 + ChosenSeq = 5 + StreamName = "TEST" + StreamSubject = "ORDERS.*" + StreamSubjectPrefix = "ORDERS." + ) + + for _, ClusterSize := range []int{ + 1, // Single server + 3, // 3-node cluster + } { + R := ClusterSize + t.Run( + fmt.Sprintf("Nodes:%d,Replicas:%d", ClusterSize, R), + func(t *testing.T) { + // This is the success condition for all sub-tests below + var ExpectedMsgId = "" + checkMessage := func(t *testing.T, msg *nats.Msg) { + msgMeta, err := msg.Metadata() + require_NoError(t, err) + + // Check sequence number + require_Equal(t, msgMeta.Sequence.Stream, ChosenSeq) + + // Check message id + require_NotEqual(t, ExpectedMsgId, "") + require_Equal(t, msg.Header.Get(nats.MsgIdHdr), ExpectedMsgId) + } + + checkRawMessage := func(t *testing.T, msg *nats.RawStreamMsg) { + // Check sequence number + require_Equal(t, msg.Sequence, ChosenSeq) + + // Check message id + require_NotEqual(t, ExpectedMsgId, "") + require_Equal(t, msg.Header.Get(nats.MsgIdHdr), ExpectedMsgId) + } + + // Setup: start server or cluster, connect client + var server *Server + if ClusterSize == 1 { + server = RunBasicJetStreamServer(t) + defer server.Shutdown() + } else { + c := createJetStreamCluster(t, jsClusterTempl, "HUB", _EMPTY_, ClusterSize, 22020, true) + defer c.shutdown() + server = c.randomServer() + } + + // Setup: connect + var nc *nats.Conn + var js nats.JetStreamContext + nc, js = jsClientConnect(t, server) + defer nc.Close() + + // Setup: create stream + _, err := js.AddStream(&nats.StreamConfig{ + Replicas: R, + Name: StreamName, + Subjects: []string{StreamSubject}, + }) + require_NoError(t, err) + + // Setup: create subscriptions before stream is populated + var preCreatedSub, preCreatedSubDurable *nats.Subscription + { + preCreatedSub, err = js.PullSubscribe( + StreamSubject, + "", + nats.StartSequence(ChosenSeq), + ) + require_NoError(t, err) + defer func() { + require_NoError(t, preCreatedSub.Unsubscribe()) + }() + + const Durable = "dlc_pre_created" + c, err := js.AddConsumer(StreamName, &nats.ConsumerConfig{ + Durable: Durable, + DeliverPolicy: nats.DeliverByStartSequencePolicy, + OptStartSeq: ChosenSeq, + Replicas: R, + }) + require_NoError(t, err) + defer func() { + require_NoError(t, js.DeleteConsumer(c.Stream, c.Name)) + }() + + preCreatedSubDurable, err = js.PullSubscribe( + "", + "", + nats.Bind(StreamName, Durable), + ) + require_NoError(t, err) + defer func() { + require_NoError(t, preCreatedSubDurable.Unsubscribe()) + }() + } + + // Setup: populate stream + buf := make([]byte, 100) + for i := uint64(1); i <= NumMessages; i++ { + msgId := nuid.Next() + pubAck, err := js.Publish(StreamSubjectPrefix+strconv.Itoa(int(i)), buf, nats.MsgId(msgId)) + require_NoError(t, err) + + // Verify assumption made in tests below + require_Equal(t, pubAck.Sequence, i) + + if i == ChosenSeq { + // Save the expected message id for the chosen message + ExpectedMsgId = msgId + } + } + + // Tests various ways to consume the stream starting at the ChosenSeq sequence + + t.Run( + "DurableConsumer", + func(t *testing.T) { + const Durable = "dlc" + c, err := js.AddConsumer(StreamName, &nats.ConsumerConfig{ + Durable: Durable, + DeliverPolicy: nats.DeliverByStartSequencePolicy, + OptStartSeq: ChosenSeq, + Replicas: R, + }) + require_NoError(t, err) + defer func() { + require_NoError(t, js.DeleteConsumer(c.Stream, c.Name)) + }() + + sub, err := js.PullSubscribe( + StreamSubject, + Durable, + ) + require_NoError(t, err) + defer func() { + require_NoError(t, sub.Unsubscribe()) + }() + + msgs, err := sub.Fetch(1) + require_NoError(t, err) + require_Equal(t, len(msgs), 1) + + checkMessage(t, msgs[0]) + }, + ) + + t.Run( + "DurableConsumerWithBind", + func(t *testing.T) { + const Durable = "dlc_bind" + c, err := js.AddConsumer(StreamName, &nats.ConsumerConfig{ + Durable: Durable, + DeliverPolicy: nats.DeliverByStartSequencePolicy, + OptStartSeq: ChosenSeq, + Replicas: R, + }) + require_NoError(t, err) + defer func() { + require_NoError(t, js.DeleteConsumer(c.Stream, c.Name)) + }() + + sub, err := js.PullSubscribe( + "", + "", + nats.Bind(StreamName, Durable), + ) + require_NoError(t, err) + defer func() { + require_NoError(t, sub.Unsubscribe()) + }() + + msgs, err := sub.Fetch(1) + require_NoError(t, err) + require_Equal(t, len(msgs), 1) + + checkMessage(t, msgs[0]) + }, + ) + + t.Run( + "PreCreatedDurableConsumerWithBind", + func(t *testing.T) { + msgs, err := preCreatedSubDurable.Fetch(1) + require_NoError(t, err) + require_Equal(t, len(msgs), 1) + + checkMessage(t, msgs[0]) + }, + ) + + t.Run( + "PullConsumer", + func(t *testing.T) { + sub, err := js.PullSubscribe( + StreamSubject, + "", + nats.StartSequence(ChosenSeq), + ) + require_NoError(t, err) + defer func() { + require_NoError(t, sub.Unsubscribe()) + }() + + msgs, err := sub.Fetch(1) + require_NoError(t, err) + require_Equal(t, len(msgs), 1) + + checkMessage(t, msgs[0]) + }, + ) + + t.Run( + "PreCreatedPullConsumer", + func(t *testing.T) { + msgs, err := preCreatedSub.Fetch(1) + require_NoError(t, err) + require_Equal(t, len(msgs), 1) + + checkMessage(t, msgs[0]) + }, + ) + + t.Run( + "SynchronousConsumer", + func(t *testing.T) { + sub, err := js.SubscribeSync( + StreamSubject, + nats.StartSequence(ChosenSeq), + ) + if err != nil { + return + } + require_NoError(t, err) + defer func() { + require_NoError(t, sub.Unsubscribe()) + }() + + msg, err := sub.NextMsg(1 * time.Second) + require_NoError(t, err) + checkMessage(t, msg) + }, + ) + + t.Run( + "CallbackSubscribe", + func(t *testing.T) { + var waitGroup sync.WaitGroup + waitGroup.Add(1) + // To be populated by callback + var receivedMsg *nats.Msg + + sub, err := js.Subscribe( + StreamSubject, + func(msg *nats.Msg) { + // Save first message received + if receivedMsg == nil { + receivedMsg = msg + waitGroup.Done() + } + }, + nats.StartSequence(ChosenSeq), + ) + require_NoError(t, err) + defer func() { + require_NoError(t, sub.Unsubscribe()) + }() + + waitGroup.Wait() + require_NotNil(t, receivedMsg) + checkMessage(t, receivedMsg) + }, + ) + + t.Run( + "ChannelSubscribe", + func(t *testing.T) { + msgChannel := make(chan *nats.Msg, 1) + sub, err := js.ChanSubscribe( + StreamSubject, + msgChannel, + nats.StartSequence(ChosenSeq), + ) + require_NoError(t, err) + defer func() { + require_NoError(t, sub.Unsubscribe()) + }() + + msg := <-msgChannel + checkMessage(t, msg) + }, + ) + + t.Run( + "GetRawStreamMessage", + func(t *testing.T) { + rawMsg, err := js.GetMsg(StreamName, ChosenSeq) + require_NoError(t, err) + checkRawMessage(t, rawMsg) + }, + ) + + t.Run( + "GetLastMessageBySubject", + func(t *testing.T) { + rawMsg, err := js.GetLastMsg( + StreamName, + fmt.Sprintf("ORDERS.%d", ChosenSeq), + ) + require_NoError(t, err) + checkRawMessage(t, rawMsg) + }, + ) + }, + ) + } +} + +func TestJetStreamClusterAckDeleted(t *testing.T) { + + const ( + NumMessages = 10 + StreamName = "TEST" + StreamSubject = "ORDERS.*" + StreamSubjectPrefix = "ORDERS." + ) + + for _, ClusterSize := range []int{ + 1, // Single server + 3, // 3-node cluster + } { + R := ClusterSize + t.Run( + fmt.Sprintf("Nodes:%d,Replicas:%d", ClusterSize, R), + func(t *testing.T) { + // Setup: start server or cluster, connect client + var server *Server + if ClusterSize == 1 { + server = RunBasicJetStreamServer(t) + defer server.Shutdown() + } else { + c := createJetStreamCluster(t, jsClusterTempl, "HUB", _EMPTY_, ClusterSize, 22020, true) + defer c.shutdown() + server = c.randomServer() + } + + // Setup: connect + var nc *nats.Conn + var js nats.JetStreamContext + nc, js = jsClientConnect(t, server) + defer nc.Close() + + // Setup: create stream + _, err := js.AddStream(&nats.StreamConfig{ + Replicas: R, + Name: StreamName, + Subjects: []string{StreamSubject}, + Retention: nats.LimitsPolicy, + Discard: nats.DiscardOld, + MaxMsgs: 1, // Only keep the latest message + }) + require_NoError(t, err) + + // Setup: create durable consumer and subscription + const Durable = "dlc" + c, err := js.AddConsumer(StreamName, &nats.ConsumerConfig{ + Durable: Durable, + Replicas: R, + AckPolicy: nats.AckExplicitPolicy, + MaxAckPending: NumMessages, + }) + require_NoError(t, err) + defer func() { + require_NoError(t, js.DeleteConsumer(c.Stream, c.Name)) + }() + + // Setup: create durable consumer subscription + sub, err := js.PullSubscribe( + "", + "", + nats.Bind(StreamName, Durable), + ) + require_NoError(t, err) + defer func() { + require_NoError(t, sub.Unsubscribe()) + }() + + // Collect received and non-ACKed messages + receivedMessages := make([]*nats.Msg, 0, NumMessages) + + buf := make([]byte, 100) + for i := uint64(1); i <= NumMessages; i++ { + // Publish one message + msgId := nuid.Next() + pubAck, err := js.Publish( + StreamSubjectPrefix+strconv.Itoa(int(i)), + buf, + nats.MsgId(msgId), + ) + require_NoError(t, err) + require_Equal(t, pubAck.Sequence, i) + + // Consume message + msgs, err := sub.Fetch(1) + require_NoError(t, err) + require_Equal(t, len(msgs), 1) + + // Validate message + msg := msgs[0] + require_Equal(t, msgs[0].Header.Get(nats.MsgIdHdr), msgId) + + // Validate message metadata + msgMeta, err := msg.Metadata() + require_NoError(t, err) + // Check sequence number + require_Equal(t, msgMeta.Sequence.Stream, i) + + // Save for ACK later + receivedMessages = append(receivedMessages, msg) + } + + // Verify stream state, expecting a single message due to limits + streamInfo, err := js.StreamInfo(StreamName) + require_NoError(t, err) + require_Equal(t, streamInfo.State.Msgs, 1) + + // Verify consumer state, expecting ack floor corresponding to messages dropped + consumerInfo, err := js.ConsumerInfo(StreamName, Durable) + require_NoError(t, err) + require_Equal(t, consumerInfo.NumAckPending, 1) + require_Equal(t, consumerInfo.AckFloor.Stream, 9) + require_Equal(t, consumerInfo.AckFloor.Consumer, 9) + + // ACK all messages (all except last have been dropped from the stream) + for _, message := range receivedMessages { + err := message.AckSync() + require_NoError(t, err) + } + + // Verify consumer state, all messages ACKed + consumerInfo, err = js.ConsumerInfo(StreamName, Durable) + require_NoError(t, err) + require_Equal(t, consumerInfo.NumAckPending, 0) + require_Equal(t, consumerInfo.AckFloor.Stream, 10) + require_Equal(t, consumerInfo.AckFloor.Consumer, 10) + }, + ) + } +} diff --git a/server/monitor_test.go b/server/monitor_test.go index eec4d3229c..c6c29245e5 100644 --- a/server/monitor_test.go +++ b/server/monitor_test.go @@ -4057,6 +4057,115 @@ func TestMonitorAccountz(t *testing.T) { require_Contains(t, body, `"leafnodes": 0,`) } +func TestMonitorAccountzAccountIssuerUpdate(t *testing.T) { + // create an operator set of keys + okp, err := nkeys.CreateOperator() + require_NoError(t, err) + opk, err := okp.PublicKey() + require_NoError(t, err) + + // create the system account + _, sysPK := createKey(t) + sysAc := jwt.NewAccountClaims(sysPK) + sysAc.Name = "SYS" + sysJwt, err := sysAc.Encode(okp) + require_NoError(t, err) + + // create the operator with the system + oc := jwt.NewOperatorClaims(opk) + oc.Name = "O" + // add a signing keys + osk1, err := nkeys.CreateOperator() + require_NoError(t, err) + opk1, err := osk1.PublicKey() + require_NoError(t, err) + // add a second signing key + osk2, err := nkeys.CreateOperator() + require_NoError(t, err) + opk2, err := osk2.PublicKey() + require_NoError(t, err) + oc.SigningKeys.Add(opk1, opk2) + // set the system account + oc.SystemAccount = sysPK + // generate + oJWT, err := oc.Encode(okp) + require_NoError(t, err) + + // create an account + akp, apk := createKey(t) + ac := jwt.NewAccountClaims(apk) + ac.Name = "A" + // sign with the signing key + aJWT, err := ac.Encode(osk1) + require_NoError(t, err) + + // build the mem-resolver + conf := createConfFile(t, []byte(fmt.Sprintf(` + listen: 127.0.0.1:-1 + http: 127.0.0.1:-1 + operator = %s + resolver = MEMORY + system_account: %s + resolver_preload = { + %s : %s + %s : %s + } + `, oJWT, sysPK, sysPK, sysJwt, apk, aJWT))) + + // start the server + s, _ := RunServerWithConfig(conf) + defer s.Shutdown() + + // create an user for account A, or we don't see + // the account in accountsz + createUser := func() (string, string) { + ukp, _ := nkeys.CreateUser() + seed, _ := ukp.Seed() + upub, _ := ukp.PublicKey() + uclaim := newJWTTestUserClaims() + uclaim.Subject = upub + ujwt, err := uclaim.Encode(akp) + require_NoError(t, err) + return upub, genCredsFile(t, ujwt, seed) + } + + _, aCreds := createUser() + // connect the user + nc, err := nats.Connect(s.ClientURL(), nats.UserCredentials(aCreds)) + require_NoError(t, err) + defer nc.Close() + + // lookup the account + data := readBody(t, fmt.Sprintf("http://127.0.0.1:%d%s?acc=%s", s.MonitorAddr().Port, AccountzPath, apk)) + var ci Accountz + require_NoError(t, json.Unmarshal(data, &ci)) + require_Equal(t, ci.Account.IssuerKey, opk1) + + // now update the account + aJWT, err = ac.Encode(osk2) + require_NoError(t, err) + + updatedConf := []byte(fmt.Sprintf(` + listen: 127.0.0.1:-1 + http: 127.0.0.1:-1 + operator = %s + resolver = MEMORY + system_account: %s + resolver_preload = { + %s : %s + %s : %s + } + `, oJWT, sysPK, sysPK, sysJwt, apk, aJWT)) + // update the configuration file + require_NoError(t, os.WriteFile(conf, updatedConf, 0666)) + // reload + require_NoError(t, s.Reload()) + + data = readBody(t, fmt.Sprintf("http://127.0.0.1:%d%s?acc=%s", s.MonitorAddr().Port, AccountzPath, apk)) + require_NoError(t, json.Unmarshal(data, &ci)) + require_Equal(t, ci.Account.IssuerKey, opk2) +} + func TestMonitorAuthorizedUsers(t *testing.T) { kp, _ := nkeys.FromSeed(seed) usrNKey, _ := kp.PublicKey() diff --git a/server/norace_test.go b/server/norace_test.go index 3f8b7c874f..bc0c604e35 100644 --- a/server/norace_test.go +++ b/server/norace_test.go @@ -10848,3 +10848,68 @@ func TestNoRaceJetStreamStandaloneDontReplyToAckBeforeProcessingIt(t *testing.T) } } } + +// Under certain scenarios an old index.db with a stream that has max msgs per set will not restore properly +// due to and old index.db and compaction after the index.db took place which could lose per subject information. +func TestNoRaceFileStoreMaxMsgsPerSubjectAndOldRecoverState(t *testing.T) { + sd := t.TempDir() + fs, err := newFileStore( + FileStoreConfig{StoreDir: sd}, + StreamConfig{Name: "zzz", Subjects: []string{"foo.*"}, Storage: FileStorage, MaxMsgsPer: 1}) + require_NoError(t, err) + defer fs.Stop() + + msg := make([]byte, 1024) + + for i := 0; i < 10_000; i++ { + subj := fmt.Sprintf("foo.%d", i) + fs.StoreMsg(subj, nil, msg) + } + + // This will write the index.db file. We will capture this and use it to replace a new one. + sfile := filepath.Join(fs.fcfg.StoreDir, msgDir, streamStreamStateFile) + fs.Stop() + _, err = os.Stat(sfile) + require_NoError(t, err) + + // Read it in and make sure len > 0. + buf, err := os.ReadFile(sfile) + require_NoError(t, err) + require_True(t, len(buf) > 0) + + // Restart + fs, err = newFileStore( + FileStoreConfig{StoreDir: sd}, + StreamConfig{Name: "zzz", Subjects: []string{"foo.*"}, Storage: FileStorage, MaxMsgsPer: 1}) + require_NoError(t, err) + defer fs.Stop() + + // Put in more messages with wider range. This will compact a bunch of the previous blocks. + for i := 0; i < 1_000_001; i++ { + subj := fmt.Sprintf("foo.%d", i) + fs.StoreMsg(subj, nil, msg) + } + + var ss StreamState + fs.FastState(&ss) + require_Equal(t, ss.FirstSeq, 10_001) + require_Equal(t, ss.LastSeq, 1_010_001) + require_Equal(t, ss.Msgs, 1_000_001) + + // Now stop again, but replace index.db with old one. + fs.Stop() + // Put back old stream state. + require_NoError(t, os.WriteFile(sfile, buf, defaultFilePerms)) + + // Restart + fs, err = newFileStore( + FileStoreConfig{StoreDir: sd}, + StreamConfig{Name: "zzz", Subjects: []string{"foo.*"}, Storage: FileStorage, MaxMsgsPer: 1}) + require_NoError(t, err) + defer fs.Stop() + + fs.FastState(&ss) + require_Equal(t, ss.FirstSeq, 10_001) + require_Equal(t, ss.LastSeq, 1_010_001) + require_Equal(t, ss.Msgs, 1_000_001) +} diff --git a/server/opts.go b/server/opts.go index ac3988235f..931fa7868f 100644 --- a/server/opts.go +++ b/server/opts.go @@ -1195,6 +1195,22 @@ func (o *Options) processConfigFileLine(k string, v any, errors *[]error, warnin opFiles = append(opFiles, v) case []string: opFiles = append(opFiles, v...) + case []any: + for _, t := range v { + if token, ok := t.(token); ok { + if v, ok := token.Value().(string); ok { + opFiles = append(opFiles, v) + } else { + err := &configErr{tk, fmt.Sprintf("error parsing operators: unsupported type %T where string is expected", token)} + *errors = append(*errors, err) + break + } + } else { + err := &configErr{tk, fmt.Sprintf("error parsing operators: unsupported type %T", t)} + *errors = append(*errors, err) + break + } + } default: err := &configErr{tk, fmt.Sprintf("error parsing operators: unsupported type %T", v)} *errors = append(*errors, err) diff --git a/server/opts_test.go b/server/opts_test.go index b42c8d9b85..351603dfa6 100644 --- a/server/opts_test.go +++ b/server/opts_test.go @@ -2932,6 +2932,32 @@ func TestReadOperatorJWT(t *testing.T) { } } +const operatorJwtList = ` + listen: "127.0.0.1:-1" + system_account = SYSACC + operator: [ + eyJ0eXAiOiJqd3QiLCJhbGciOiJlZDI1NTE5In0.eyJqdGkiOiJJVEdJNjNCUUszM1VNN1pBSzZWT1RXNUZEU01ESlNQU1pRQ0RMNUlLUzZQTVhBU0ROQ01RIiwiaWF0IjoxNTg5ODM5MjA1LCJpc3MiOiJPQ1k2REUyRVRTTjNVT0RGVFlFWEJaTFFMSTdYNEdTWFI1NE5aQzRCQkxJNlFDVFpVVDY1T0lWTiIsIm5hbWUiOiJPUCIsInN1YiI6Ik9DWTZERTJFVFNOM1VPREZUWUVYQlpMUUxJN1g0R1NYUjU0TlpDNEJCTEk2UUNUWlVUNjVPSVZOIiwidHlwZSI6Im9wZXJhdG9yIiwibmF0cyI6eyJhY2NvdW50X3NlcnZlcl91cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwMDAvand0L3YxIiwib3BlcmF0b3Jfc2VydmljZV91cmxzIjpbIm5hdHM6Ly9sb2NhbGhvc3Q6NDIyMiJdLCJzeXN0ZW1fYWNjb3VudCI6IkFEWjU0N0IyNFdIUExXT0s3VE1MTkJTQTdGUUZYUjZVTTJOWjRISE5JQjdSREZWWlFGT1o0R1FRIn19.3u710KqMLwgXwsMvhxfEp9xzK84XyAZ-4dd6QY0T6hGj8Bw9mS-HcQ7HbvDDNU01S61tNFfpma_JR6LtB3ixBg, + eyJ0eXAiOiJKV1QiLCJhbGciOiJlZDI1NTE5LW5rZXkifQ.eyJqdGkiOiIzTVJCS1BRTU1IUjdOQVFQU080NUlWTlkyMzVMRlQyTEs0WkZFVU1KWU9EWUJXU0RXWlRBIiwiaWF0IjoxNzI2NTYwMjAwLCJpc3MiOiJPQkxPR1VCSVVQSkhGVE00RjRaTE9CR1BMSlBJRjRTR0JDWUVERUtFUVNNWVVaTVFTMkRGTUUyWCIsIm5hbWUiOiJvcDIiLCJzdWIiOiJPQkxPR1VCSVVQSkhGVE00RjRaTE9CR1BMSlBJRjRTR0JDWUVERUtFUVNNWVVaTVFTMkRGTUUyWCIsIm5hdHMiOnsic2lnbmluZ19rZXlzIjpbIk9ES0xMSTZWWldWNk03V1RaV0I3MjVITE9MVFFRVERLNE5RR1ZFR0Q0Q083SjJMMlVJWk81U0dXIl0sInN5c3RlbV9hY2NvdW50IjoiQUNRVFdWR1NHSFlWWTNSNkQyV01PM1Y2TFYyTUdLNUI3RzQ3RTQzQkhKQjZGUVZZN0VITlRNTUciLCJ0eXBlIjoib3BlcmF0b3IiLCJ2ZXJzaW9uIjoyfX0.8kUmC6CwGLTJSs1zj_blsMpP5b6n2jZhZFNvMPXvJlRyyR5ZbCsxJ442BimaxaiosS8T-IFcZAIphtiOcqhRCg + ] +` + +func TestReadMultipleOperatorJWT(t *testing.T) { + confFileName := createConfFile(t, []byte(operatorJwtList)) + opts, err := ProcessConfigFile(confFileName) + if err != nil { + t.Fatalf("Received unexpected error %s", err) + } + + require_Equal(t, len(opts.TrustedOperators), 2) + require_Equal(t, opts.TrustedOperators[0].Name, "OP") + require_Equal(t, opts.TrustedOperators[1].Name, "op2") + require_Equal(t, opts.TrustedOperators[0].SystemAccount, "ADZ547B24WHPLWOK7TMLNBSA7FQFXR6UM2NZ4HHNIB7RDFVZQFOZ4GQQ") + require_Equal(t, opts.TrustedOperators[1].SystemAccount, "ACQTWVGSGHYVY3R6D2WMO3V6LV2MGK5B7G47E43BHJB6FQVY7EHNTMMG") + // check if system account precedence is correct + require_Equal(t, opts.SystemAccount, "SYSACC") + +} + // using memory resolver so this test does not have to start the memory resolver const operatorJwtWithSysAccAndMemResolver = ` listen: "127.0.0.1:-1" diff --git a/server/server.go b/server/server.go index 4907bd5b85..c2693332ab 100644 --- a/server/server.go +++ b/server/server.go @@ -1990,9 +1990,9 @@ func (s *Server) updateAccountWithClaimJWT(acc *Account, claimJWT string) error accClaims, _, err := s.verifyAccountClaims(claimJWT) if err == nil && accClaims != nil { acc.mu.Lock() - if acc.Issuer == _EMPTY_ { - acc.Issuer = accClaims.Issuer - } + // if an account is updated with a different operator signing key, we want to + // show a consistent issuer. + acc.Issuer = accClaims.Issuer if acc.Name != accClaims.Subject { acc.mu.Unlock() return ErrAccountValidation diff --git a/test/configs/certs/rdns/ca.key b/test/configs/certs/rdns/ca.key index ce71258866..81e8d5e0d5 100644 --- a/test/configs/certs/rdns/ca.key +++ b/test/configs/certs/rdns/ca.key @@ -1,27 +1,28 @@ ------BEGIN RSA PRIVATE KEY----- -MIIEpAIBAAKCAQEAxy40ry7asGdHhVW/Em748HK1OEfXIcEY3UijZ/RzwpUV8DI+ -jTXwL4N6V0TCC3K9JVO2dOZuVtBbqTr/yF683MeBk7QqqGNwtRfVOiYNP2Aq59WJ -FJ/DbGxZ2h8DZ4mV6DCeynQmbLmjr+Xu5O43E2zHoRgOgDXj5oUVdZxfFOUIqJtc -JpIiISwvDu0xTjvdK39tUS6a347oRjM//WXLbJz6nLfvnrlmnqu0Oy0UV14uaKXO -6t2Jo62oXB70i5rdatmfraC5SwzgwLXUBZeC9slh9s4rqz3XLNdVmARofHvD7SEE -Pdv1vFsHeVj1b1sE2UOrhnZSB3dDRMp1se6L3QIDAQABAoIBAQCdNxJsqC4DiTHB -w8GyehdSKyhxSPs88F6A44HfXus0TlrnobEP4uA3kK6zTVlgketMGDxvHyc+rO18 -sU4NyQGHvo2/mTkGep8OwcYTRM+2E2EqZrjxp30oCooNiec1BTtm72GW6YEe1pSm -FXawCns8gOM9e3COsHq3jJo4n/nI0e0hh4nbwzFCjJEZfKoRV2hwBB2md7GitMJT -k8ZAYOuiljA99cNYums0/h8+jVIxTxJCY+GYlqD8RcRUVyojEttQNrtW9Y3RRnoG -R8GDyKkIV77CMmSruQanvmlp5EZoGzg2CfeyoyD6Cna94UvO9dloP3ic8zsQpX4B -lVb1ymrdAoGBAPhdaExpN63L9Xl1e4FzTOCzAf7eNZnccoxVB51WD8O9ameQymCc -uSK6c2FJt/yE7YYxnfBv5KDvH0q7S7oFthMvnlWWU1ZTcDE/cJ66JqT2lT1w+dKh -KG588A/V9nqx7GXAmzbhNTJSl9uy0mLDHkBNIVFBjkjheVz49gHMwVo3AoGBAM1N -uZq8rhcWaxrSwhLXqjkIZnrxLpRzqTLmQfhvw61UkyM3Xn2C2dZqYJOw22W2zymu -FcAuWlHW7Bqt7WGJ6Ydw6/EEk4hvmxXpwH7Sgm07HblKfebRpfLbD+ls7O7sMwfC -rOZJT+XTpChTDbVRjRI799PisSIG57r6eAKXGfCLAoGAd6fY1edjMdIvo6KcLBO2 -mBLmBTpdLJFuhnl4v650zeL13ot9VOpsr3SQnfB8OaZ5IMvKwcnGplpOAx0VMLwL -qlaou6c+4zoztSZRRcd9UsCRyhYh5f5KkmCS764vn5EUyTjwDpKVpHbyPqB6h6Zl -bqk6QgGJYUdvxwES1G8nQCUCgYAibK77iDm0u1iYNdC+8hSj3Ym5galq0P4E/+D9 -9FeeP7kwRX99kixOrKWm/he7tWyFM6CICf2xDVWnn5RXL5XN1Rxq3HaUgQpDIV/a -pBekky4HvLrhsjOeRicj39TWtxpTacwuDQrtoZA8BrkctyDtdsq2Z6OF7hx7GLZ4 -0LdTwwKBgQCqv+711H/O8RP5nTbGcyvJbCKmGkmbAaywcCPqiHMBAmpmZDAUGMg1 -KHEf4corIHcMKOJOYfAO6Ie2fUOQr7UXUsw8zqoo5g5WaZE02rh2MUWgnxh55AH6 -4rN/7kWleOY1uDEPdr4uMc4F0jC52/T5vmuCKEtHjgEt144v6+rFpA== ------END RSA PRIVATE KEY----- +-----BEGIN PRIVATE KEY----- +MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQDd8u+Lbq5qjxj0 +D8YdouHVlsnH+8UH1spKRr53wRqdPX7qC9eyBDMJ8ltUVAfQcKjXqP3EN22rAm+1 +L8vSXcdqxO2pGStXbfrdvDIeiMuJJ2zpz4m3g5T98AcNFUxyUQet4rLHtQGyzK+S +sTSOKCg7hULMvnXMLjUJTBsDgSYPNxLw3jlbppTaEVhna74d0aRNBkHVJvO8BJsT +J39iz2SrhvGzGfhK2Jbov0QPC44hIV28AFrwKbJI8gB7kD9BWe4hNfqoECLP2K/Z +qYw27Ybr9nUVC3ZSnTudAueHwsT+Pa5qbBoNw4QGwyCc7y9nolIOosi7RK1LxxOS +477I9ORrAgMBAAECggEAB2C0csOWm6cvEqnVkZWhASsWgQXO+mA68DYizbNHEbQC +HICRRnMaSTnbrFVwvw6HpkeRS+z1wcn+cZzpnxAL+XIbXlQeWzUmMim31skATwpW +9fy2nLmMgdZxPY+YL3KfGTogbEAJkup36Z3nW9Rc5gGbg1fPbZ6Zl7oGadroq3e+ +0mKdUzKNw46VVUpoHIq5ty/5mGyiew0E6IJEv3tD8MtFZ9r29zyDF6thsj3k1K+l +elRc6hgvP74RI4vJ6yNGWgJRoLK4mHAxhS6Zew3aVr/5P9P0WRnj2WD65geUgaFv +hCcJzqkGQPUl2CGRkspIUErpJkAZRyJyjuw/XU91aQKBgQD9dy6nqqfTpf/+dWzc +VltdhlEuGfXN1Yfg9A4w+o3+goeFwt0dim6plX/iSLbohylXbpPcugx+OMIw0xHs +ZsT8L1NIUSiXIri+VIU+5iU5X+tQUlCXnTy1MhqRSI0BD02Ac/+MMp36RmYXgghd +MIiMN11wDbeGsCzjDecziALi0wKBgQDgKxPmUniPe5eBF3QrpDpBnaxZEz1/e0Hq +xKcN7ClCbfPSvyIGJhB2NJR597vfaHCwsp7ReUK1RrvmRBaBg8bFffCbEfFSyB5c +pZ6r9BXBhPTB9NMsnMn/e3Al8sVcYWbZdgkkxuVE5DdWZS3zXscmTzls/RPvDlOK +yLI+GaiJCQKBgHxjGtBJnabuVhzoP446CwhwvDIlp01mNxKccsJyk3CNWji4ko7G +utwac/H2wVyHyDASIho2a58d957CVo9vN8iS6QoaWhMhhQxSqjld9HKdsftvCgH9 +tict+X/G3PviKKSbSJPi20hReBSdScGB6eD14rL06FX+62haEFZnrxLlAoGAYrK0 +zUjsagg5mY3xCTICsFcyxflRr2peiHZTMy8Sr3vnyZd77Icf4lueL+FiZ6f9Td8n +TAV+2H+vRWAfJKEXiGa95BjPTupra9FD/mO2nIDknu0jeVYDHiiEJUExok4EUaTF +u9qSoXV14+UiiS/msThaiWEYQL3nDIj26Z60dLkCgYBBrZN/M8NwT111KFGXgYzm +CxFCu1WPCRUXIKVJjbj9reJgfHMhj58NFpqtVSS4KNeoc6ZGOfkAT/Nb1/H001TF +AK3CBTGzFQiqNmvmWP+0O6JaqVXPgHXXRCdXz9CnJmyIeJqvQbQEZPlIC4cTOi3U +Yr+e93q7SOS6wbf446ij5A== +-----END PRIVATE KEY----- diff --git a/test/configs/certs/rdns/ca.pem b/test/configs/certs/rdns/ca.pem index 162c2dde6a..26b625886a 100644 --- a/test/configs/certs/rdns/ca.pem +++ b/test/configs/certs/rdns/ca.pem @@ -1,19 +1,19 @@ -----BEGIN CERTIFICATE----- -MIIDBTCCAe2gAwIBAgIUJW8TRwSh3p0M7H5bPztnju7SI98wDQYJKoZIhvcNAQEL -BQAwEjEQMA4GA1UEAwwHTkFUUyBDQTAeFw0yMjA5MDcyMDAzMjFaFw0yNDA5MDYy -MDAzMjFaMBIxEDAOBgNVBAMMB05BVFMgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IB -DwAwggEKAoIBAQDHLjSvLtqwZ0eFVb8SbvjwcrU4R9chwRjdSKNn9HPClRXwMj6N -NfAvg3pXRMILcr0lU7Z05m5W0FupOv/IXrzcx4GTtCqoY3C1F9U6Jg0/YCrn1YkU -n8NsbFnaHwNniZXoMJ7KdCZsuaOv5e7k7jcTbMehGA6ANePmhRV1nF8U5Qiom1wm -kiIhLC8O7TFOO90rf21RLprfjuhGMz/9ZctsnPqct++euWaeq7Q7LRRXXi5opc7q -3YmjrahcHvSLmt1q2Z+toLlLDODAtdQFl4L2yWH2ziurPdcs11WYBGh8e8PtIQQ9 -2/W8Wwd5WPVvWwTZQ6uGdlIHd0NEynWx7ovdAgMBAAGjUzBRMB0GA1UdDgQWBBSC -H2e2QNcigFbncm0DZqsd7pW6HzAfBgNVHSMEGDAWgBSCH2e2QNcigFbncm0DZqsd -7pW6HzAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3DQEBCwUAA4IBAQB/PoyGpVU0 -LQwe4GRS4HcuOcPGjf3rRbKBtv4Qj7ZTIN7EmWH2TewyYwCv8MVRWFgH297Z8Mxy -0942Wtxad0a3XAVe8iOjD9OH654l3WAeFA9hjk2upkG21q6iZidQ79Za/wXY5eUb -+htiiv8mwwpEhi4uoqruNO+k06yIyIJRt+tgMHf3wBFz7sPcgvOwUHlWzZcSdS6w -5NNt1S2ZNXIMXeuFq87oRIjz6sU+uZSb4T/7Kh+OiNWoKAlv/hsupxIQZfqk2rbG -GqijeVk41aVjHeNKEsNhX8nLcx1XxCa9tZM+50cUqI2BPXVPwhpRP9SMGwhOGs0P -Uqp308knCx3H +MIIDBzCCAe+gAwIBAgIUC6fLO8KV763IBygl6/0w7EKectswDQYJKoZIhvcNAQEL +BQAwEjEQMA4GA1UEAwwHTkFUUyBDQTAgFw0yNDA5MDYyMjMwMjNaGA8yMTI0MDgx +MzIyMzAyM1owEjEQMA4GA1UEAwwHTkFUUyBDQTCCASIwDQYJKoZIhvcNAQEBBQAD +ggEPADCCAQoCggEBAN3y74turmqPGPQPxh2i4dWWycf7xQfWykpGvnfBGp09fuoL +17IEMwnyW1RUB9BwqNeo/cQ3basCb7Uvy9Jdx2rE7akZK1dt+t28Mh6Iy4knbOnP +ibeDlP3wBw0VTHJRB63isse1AbLMr5KxNI4oKDuFQsy+dcwuNQlMGwOBJg83EvDe +OVumlNoRWGdrvh3RpE0GQdUm87wEmxMnf2LPZKuG8bMZ+ErYlui/RA8LjiEhXbwA +WvApskjyAHuQP0FZ7iE1+qgQIs/Yr9mpjDbthuv2dRULdlKdO50C54fCxP49rmps +Gg3DhAbDIJzvL2eiUg6iyLtErUvHE5Ljvsj05GsCAwEAAaNTMFEwHQYDVR0OBBYE +FHMfJfiA8Nb10G8rKcO/am9Ogo6tMB8GA1UdIwQYMBaAFHMfJfiA8Nb10G8rKcO/ +am9Ogo6tMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQELBQADggEBABMr45yW +SDHQ+zOW6MXCn2CAqagr9TaRjkqYmaaNh0uDBI+oaFKi8WHCi7jt1iSb2f8wp6dv +jQ97osGsAsU5KgyyliweIaTftd58oegpmADwpQTpVa2RIz6o4z2FKnDm6ZtH5fm+ +RRS+FpcS81s1m6e3gJ3Ie4nIqQRrBcvKpQEgMgiwJH4v2rIB0RvkTztA2EeVyyH/ +IjbrbO6Rc7EpEJNbsVWHcKt0tMNx9F1qicgscrcEgAPG77yz1bP4jKSqhXt6OhM9 +lhXFq+EbzAhbPzkgQuxghHxJuDNZDafKvf1cl/b7jEykLEiKo3s1oto+9yzRKZ2y +uKJ+WESZ0V6XOU4= -----END CERTIFICATE----- diff --git a/test/configs/certs/rdns/client-a.key b/test/configs/certs/rdns/client-a.key index fefa093620..c6c6755b79 100644 --- a/test/configs/certs/rdns/client-a.key +++ b/test/configs/certs/rdns/client-a.key @@ -1,28 +1,28 @@ -----BEGIN PRIVATE KEY----- -MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCU9A5dRhbngJoT -BRdIUsoh9gnxblk8d7vUoN8qQBcX3HjPb/YAzpEdVnNam8+WL6w6tWd7FBAH2PK7 -ZgGgNuNlma3HIwvjeiaK6aJOasfImcWIVOEveF117tseqhywDC6bYVLwSywSN23e -iTdEDH6zZV3GZZmM+Xg3ZdHq/etK17//6dJVaka5d+kMi/07zW20f8zpGf/JXrE5 -eE6Jyy1S6aysDzGFdPEPf/A5Xkv92Gj0WD9EbMIqSRGuQhf9eEYuaoqaJ4gj52bB -sMPFl1mwBMGT/XZQtQTpcTzYRdSkjPqNVJgQozckTxVKtktiL3pmkpxEYp8YzzGg -J1+ZbLApAgMBAAECggEANy1VKN4u2+D6sjL/le39LKlss3+yFMEx1iklogwNwewM -4KLT2SasANcmchknw7WzMihCxgf/jDikaiD2Vzgd8mQESLFF1SVJo8m6MxxBF6FG -2CLBLAmFbYtmpixT5i8NEMfzpknicHkR/Q6NZ2rNgHz7SOQYBm3fR34zTb5z68wB -hXlAUKImN/Gpf1rwEix7JLMHNxj6vf/f+vP50IEa3cMWHbrUN3O/w0xjDNBKbhpR -ILtTZEl19/GFHXV0yxjo6SWsCIP7SkeNL53HamLS4WcOkQKdNx7rV2OSrr5aDxQF -iCaVKKSEsjilKaoKVANs77daCiwyKlJa8VsXZoU8ZQKBgQDGaqqR67QXbtEFwhsa -MLO4G2G78yNNsFCtgrlc1HDnDpGThSJdbUanncPIoH6+SDtRFh+nRO9fnKmqvFZ4 -t5eoqo9ZeNUKg3tIZ/+dR18QLE4z5UZncVCH37lCXQpdeoIk4su8tnVmAfrgOT67 -mLrfNKqdPXyJ1WR+xTZ5mlkPpwKBgQDALoU9oVo+qkkQj2POgCd6TUltk2tANmfI -sg3H3xnZ9gmqht0d+DARFLoS2mVjOuz6u1gXGbop1pFK18ix0NIodyS1oCgnnoPv -SVObDifzQRyeUlxDe/ZyZ8fWWdtsj9/InsaYJZg7rC36TvaOARfiimg0U4Fiu1Fr -aoq7GoS7rwKBgQC5Yg/cJo0tF6zT5HfOEJLaATtfj9v8SjAW7Xyi7xpNx57cZhel -kuPg19aFLO8+ed5x9Gm+rvm4K3eavj1MrLxWKoWk4vCp0g7tp718BaMcSUkH07/k -Bktnp/A/wQ5eKIhQTlZtC0zE8jSkKtgiDqEKyvpdz4T8gxRSHZC4LS3pIQKBgCkK -xlG/H7K6UxhCRyJWpBeuYbwQ+5qfA9MMk3zX3IF71dyhKJ+53SoIryRPl891Sh7R -26IzUFqXBDhjlOzEl90kdKaFKY4sgCieFEjM4SNGCIKXPDT9SEhueXMBhabNoxEJ -N4hOnxA/WSJXsrfo69zpig+CteML9ftmqXID28zpAoGAbxAAW7FUr5cWb86dIQhH -nDHKGbVl0SLBBIq+iEKdTQTZaAX1wEE/tNlz13b2W8fEEdPBcctJCokfLpnnrJdN -XrvHhOSFKtqEIAwEfDIWn312Q+gwPCuKXneKJ8qlMtI6qaWiCA/YhJOaniR/kwzh -+o2AjZBpa9/DSRivxABUtyU= +MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQC2yUu/qqBD+rKF +q2f2ISuw7KZlpne5NN4RXhAK1fe1b6TtZi/hDeDaBo0A5ttFn+lmb99DWwQh5UZO +OrjueeZLjhkMIBqmVY0Z8wu0BudYFWrjbEEFz2oAN4UXxu6PvKdcHsJQHbMjVvxS +j7GauUafZ1MZmcxRizQDW0+bD0NDKERR4JropXC+9Cths9MG8VKXGzYEBX1g9j2r +pRZ064ZDUEM3ImZI5fAdeUPZuutg2J9swgXvppVpXOMQPGR6TUZsQZC8Z39zm3OK +vsyqKE519gpC5ZNTMm9xaD+Dd8tyv3OhMnVZvIEBvtJysKS076cGqxwIeFNZ5zky +iNzZ6A2jAgMBAAECggEATs2pDSiEMNqf5bYYu4ngesYEFRX4Ts5GoSky9GD8Cupn +qfvgz3+6vXSOjOF6jmFbcFDx6emO9ggRT//MI/BFA7TvAoXCx4xhqVrZ5FMHoTeW +nhbZT6Z09kP5at9WkXyNkM8oCf9L8IP7g6K0uNaA5o9WydY/OravhXTz9I9Xeddi +6Cgjr42PVqpdlN/CvQQ+ISYGSYzg6r/o8gaIg1zypJPm3DqZ+TFBxalv7d0FoH54 +eagk+blA6kUGvJ/CX5Fr19hliycDNfxT/uofdVKEUXSWlPQgzvGk6Pb0B/Jco0C5 +BDuvA97LigY4AR5FXZa2wmYhdlBontjixiZNFgeqHQKBgQDn4XriO8ZNkERW4e2V +aLrkRH5nd3IqRX9aUn7Qz1xXV+nE9+984Mwk0xtTkwtmmiII8v+2cfz1J7I+HVB9 +NRFGtcKX2REEM6wp+UPJi8HFx1uOr3Mi/JM8i+1/vq9YPXR4DJ0CBJwydTQo0zIz +jJrqKPUiEAtrAmT4YCz/hdrARQKBgQDJzIdWWCv8LeyFBdJJHikjSy1PETFMoeRj +FEtdi3Oqninn99ovV43fgVXK2C38OaiO0X7N1OwXtJhWaBU5TkmlEbXe7eNlayFc +RFfEmg3RFItFEU348oyNuhqDU7RRG6FapMOX6fAIhaF0Ox+qLlwsW+uNbjxcq/5Q +JIhLji+4xwKBgFk9V9OVeZ4ENajSTmM/6R1MlvEu8Qr/sCGMui2WgE1FEjyxxsNi +qG5LqKqjXrHgA9U539vRRq761gg9s+pb8Agsj3VtHrVlRY7p1YLNfIenT788Gq2O +UwPsPjz5n/XvwNEq2YobSBnLLYXAsgNQy5XuqViwoBRQ2ZcVPHwigauZAoGASzFu +7HmGSj1CeH6m0J/wbDpC88dQO2HHnDOfsYeY3eZ5bvonzqQtNS8YLLFI0Ucay7y8 +Jy5DmsGsUeYOon/NaTikMCEsLkow8BR3L8bHhzTEgEPmbfDS9qx13KF/+wj0orXq +O9zrmAFTG+A7+Em2BsFpkBWXYGCmLm6uapjcp1kCgYA1cGEgpOXGv3HR21ItrpWh +wx/iEqybIdYU5bOr1OxZJE6PgWD3k0DcPAFGbfJX8I5AEQQHhbufv+QMwfdm4irt +/EMWE+5MzmCOPKQzb3jLhvdqAKie2rnDFuFvlhT2woDxQaY5gaS3Tay380WZ3+rW +tHA+wi2+w8REX4KLuaY25A== -----END PRIVATE KEY----- diff --git a/test/configs/certs/rdns/client-a.pem b/test/configs/certs/rdns/client-a.pem index ae397d8713..aa25f67ed3 100644 --- a/test/configs/certs/rdns/client-a.pem +++ b/test/configs/certs/rdns/client-a.pem @@ -1,21 +1,22 @@ -----BEGIN CERTIFICATE----- -MIIDZTCCAk2gAwIBAgIUbM5eMdzKfamh0SDEqztq73kUDmAwDQYJKoZIhvcNAQEL -BQAwEjEQMA4GA1UEAwwHTkFUUyBDQTAeFw0yMjA5MDcyMDAzMjFaFw0yNDA5MDYy -MDAzMjFaMIGOMQswCQYDVQQGEwJVUzELMAkGA1UECAwCQ0ExFDASBgNVBAcMC0xv -cyBBbmdlbGVzMQ0wCwYDVQQKDAROQVRTMQ0wCwYDVQQLDAROQVRTMRIwEAYDVQQD -DAlsb2NhbGhvc3QxFDASBgoJkiaJk/IsZAEZFgRmb28xMRQwEgYKCZImiZPyLGQB -GRYEZm9vMjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAJT0Dl1GFueA -mhMFF0hSyiH2CfFuWTx3u9Sg3ypAFxfceM9v9gDOkR1Wc1qbz5YvrDq1Z3sUEAfY -8rtmAaA242WZrccjC+N6Jorpok5qx8iZxYhU4S94XXXu2x6qHLAMLpthUvBLLBI3 -bd6JN0QMfrNlXcZlmYz5eDdl0er960rXv//p0lVqRrl36QyL/TvNbbR/zOkZ/8le -sTl4TonLLVLprKwPMYV08Q9/8DleS/3YaPRYP0RswipJEa5CF/14Ri5qiponiCPn -ZsGww8WXWbAEwZP9dlC1BOlxPNhF1KSM+o1UmBCjNyRPFUq2S2IvemaSnERinxjP -MaAnX5lssCkCAwEAAaM2MDQwMgYDVR0RBCswKYIJbG9jYWxob3N0ggtleGFtcGxl -LmNvbYIPd3d3LmV4YW1wbGUuY29tMA0GCSqGSIb3DQEBCwUAA4IBAQAfM6IWlNRP -Ihz7NifhLOHpOm3kh4MYnvir7/GI9b8kKBf9sVW6vm1lLzUNtePrjvbJU51pbF91 -i+WPztoI5rS6kRT4VCf4IClQYlSDTn4RHRZsrqImzcYRdgqDb9FJOsiD1GqzyThz -GvSyvg08T7wIO4/fr7fUPKKSyaiBJzapSFjnTmMgvVqAVvXp7lmqkLqsZKV/FJjo -4uoNWbfszQQ4lY+lteu13VRFjQR616j78npDBhjAXLcGMF4PtJByG4YKp7IawSG1 -BtlQp/76Ik4vBY1sjUPBUMMOswGrmXQPIl9fq37YePGWSsvSiU2lupVcgMd7vfL/ -EMB07BuvTZtF +MIIDpzCCAo+gAwIBAgIURF3HIP6jjAixTsMisMxARhqRfcIwDQYJKoZIhvcNAQEL +BQAwEjEQMA4GA1UEAwwHTkFUUyBDQTAgFw0yNDA5MDYyMjMwMjNaGA8yMTI0MDgx +MzIyMzAyM1owgY4xCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJDQTEUMBIGA1UEBwwL +TG9zIEFuZ2VsZXMxDTALBgNVBAoMBE5BVFMxDTALBgNVBAsMBE5BVFMxEjAQBgNV +BAMMCWxvY2FsaG9zdDEUMBIGCgmSJomT8ixkARkWBGZvbzExFDASBgoJkiaJk/Is +ZAEZFgRmb28yMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtslLv6qg +Q/qyhatn9iErsOymZaZ3uTTeEV4QCtX3tW+k7WYv4Q3g2gaNAObbRZ/pZm/fQ1sE +IeVGTjq47nnmS44ZDCAaplWNGfMLtAbnWBVq42xBBc9qADeFF8buj7ynXB7CUB2z +I1b8Uo+xmrlGn2dTGZnMUYs0A1tPmw9DQyhEUeCa6KVwvvQrYbPTBvFSlxs2BAV9 +YPY9q6UWdOuGQ1BDNyJmSOXwHXlD2brrYNifbMIF76aVaVzjEDxkek1GbEGQvGd/ +c5tzir7MqihOdfYKQuWTUzJvcWg/g3fLcr9zoTJ1WbyBAb7ScrCktO+nBqscCHhT +Wec5Mojc2egNowIDAQABo3YwdDAyBgNVHREEKzApgglsb2NhbGhvc3SCC2V4YW1w +bGUuY29tgg93d3cuZXhhbXBsZS5jb20wHQYDVR0OBBYEFCkA7CbJMs70HE5rQxHm +qHL/UgkOMB8GA1UdIwQYMBaAFHMfJfiA8Nb10G8rKcO/am9Ogo6tMA0GCSqGSIb3 +DQEBCwUAA4IBAQC87KaD2UuvQWIbSPOKy2iPc5bHrsmzxtPzT219NqzI4JZ9QeAz +btvLlMxgACreCb6wzYxaOjbU+O2LqO7mq/M4UyY1+wrAwYn+c3rVcimuPa2bGKin +Le+aBr/4yXAahqH4DW5K4x3x/7c7wyNlj9MHUQDl9A/JHsit68hw1YY/1ALPaOpg +9L5K52gGHVXrxb8In8OkJEoM38G5Zstiuh1umsWNWBp6Nd/FlNr+XbvNuFsWLC/V +lTaHxFt9WRQNINc8RpK4YCHRdaOiEqAGexDkHgNaLHeHEwCvP3Zhj7Zpp+svlmm8 +cLL2A5wl0T0OEehT9wxKaG5cyP7jfYfJmENW -----END CERTIFICATE----- diff --git a/test/configs/certs/rdns/client-b.key b/test/configs/certs/rdns/client-b.key index 990c69b38a..7be1ab07e9 100644 --- a/test/configs/certs/rdns/client-b.key +++ b/test/configs/certs/rdns/client-b.key @@ -1,28 +1,28 @@ -----BEGIN PRIVATE KEY----- -MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQDURq+G1+EVl6ee -9kcHZ3GO27RLVq9MuYzXGG8hfkprENabAxFJSyl4VJ0rCxCJQg7suUarX3OgQZxP -TATg4pRG5Fml9DAXm/cxgwALSPaEpzrYNaqc3WXKyl1vCDcLliQH3myQLakRFoDG -/7XQdfcsI6Rm7yC0DxewgPpjYP/bePJFRtFBC+fGa0EzYR0FH4G+MKXFYK49kktD -sMScMj/GkU1loVPWZvz2D8kgTJ4bwgQulCJZ2tVtPvykhP5or6oyD69mkXzbho/U -P2XVsbVebBNV1U1XMcdu+KlRRx06Fo8Jbhyd1AZN60HLq4eHPm8fUF8qf5d1R5ud -G1QUOzaZAgMBAAECggEAB8vc0IAHRUq/nkf/TddPxWZuVcIGSDQcZx3/nuRLiWkh -6KmRLfbzu/anmxgZ8GCbubgIT2z/Cyi9u+/X0gagWYYzgLPaPFO/HXNpQgDZBQA7 -WguGi6JaBbuu+M/9bZCDHELgC9+RcQ45hpWHsPNUM6vPcvRfaB2RyirCh3ndi8rx -QTCeRsgl1PAfan72bcm/7yJs3a2JbnMj556DyE30SkRzFFkaRbOyD4d//9B4n5uG -Zc9MAcbZveGrmoRb66NYV4Txf6PlkiDQt7y/DEeNvp8ngkGj7CLZolZDK0MirJhv -L8Ggt9ozDX8fv4Fo0n7g7aJSF0z+oTt9HVYjRgZ/fQKBgQDwexpH376WXGteMSxv -aGnNegCcAI1XeOCq9rxDnsK1PoqEoD+ZrW4U8IeIAJWK/dUG/ZCsAfg701UwZyyR -egxEtzTDHmA8z9w329oU8U2YKIhZ224s52anyKlOro/1IhQrPDm9ZtbBe3jYmDWi -qTvk1rZAogAV41dbWNSqkG4MOwKBgQDh+Z9aHYIBbMUIswlK8JslBDqse7c/y/i9 -rjoErbJFDphZb/VIstBNrKo7dBy0c4bi4sSEzMk7Zdxzn/EbW2mloJTVCMMK3Vv5 -rgDU+/Au2Nag+PN/iwt+ZLL0y/MKxJ1Enm1vVHV2NCtx9i606RpRpb5qgxCVb0Dw -TiPs0jXfOwKBgFckBI3u4d0SeEWVhAiKyWwPvZDKEm2T+7V32xiVuvB6TS9p8iH5 -2l30GuiJbacD++GgmH/75runBMOZX2kH1NJBoPjjVPQ0ThRfslLMbdWpOl91SCM1 -Ztl9uPwt/TRSuQRBupqLXV6XI185KJZcxLtToo8hJO7JhqovMkDsPTRpAoGALBDt -jjkq3PRFCAlByqdY2cMVXgVSGtK/0t1i2v60QNszwl0ey+pyzHLbT3S5FEdjCmOG -Rw9YPokCkFmkPt14oJ/L5i8rObco9GuGJgJrN/d5AzMI6NpIh4FDlJEg9/yXXoY2 -ePtTXJWX00VanlTGmR1lIIgmd72WQEY8ozXq43kCgYA7p033o7o3u4fO6zxWyfwG -B3BY4Oie3Hthxbrs+JFl2lQs2VjFxx5AJs3Ogyt5fHC9O0d4t85ScUQp0PazhenV -L5xhQarTGSpwVpCynDyTG6UGWYLBUx/uKoECyu2J3nhx93939+4tGPqmRy0Qpo4g -IPzGUnZTq8WRMs+QJhvHog== +MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDSHSxxgyq3Yd4H +LpzmpRceCQ8y4qqsysiZ2C/9HhwcvvoUXRJvLB5VzYb1702AZNgbeffrz8RRGcaa +YuPRXwkitRGb/MdmC/AFi2aALk1M4EKzGhw5IjyL6tfk+qahxm0IACJVQW9W7Ts8 +O6odqnqenvXLzvTNn0UWWv7jZonOpqnR36CoxIj9WGNXIlwDtcTwCoLfd9V+kUzX +PybIVrAL13tLPypZ7fpyAkwd/4qYAZ59HbRsQDNvYItkwe4JQiFt4PQ94+eGDXtk +DqttKPi4uUUgSGqRzTNkvkM+KAghRD45XN2J1ugw16GGUt4sQKPViTDh06yQ/OTR +X7CyuvmHAgMBAAECggEAGBhPXe8QSXpYJ1Oxm4OIHKImU4wJzYntqjLQAgNfbu55 +qDcqI4SYL/fDR9W6+gPWgoQgqbKoTTKbA15eyMZQumGwVMaOqUWqL0CWrxFgPPYk +v/w5C1ZBQjxaqMATts6V90popYU8+ud2mQgwkHlZ2XHaNxaTHTdsCU3DGBnMqN1f +tq3glwkHZqUxKsGXwWqSKsDwEUXpcs2ww0fbuzpdZ5IokPX9e9TdFkw10rKXboRn +owcTxHI8kuTVMFg9ht4G39V/LVpqrPsHGz4Zj0tJ8PkwxowcwLMcxg2KVsHRWzC+ +i5UVlzjWVK/Gu1mMMCfySJLBi4GaO88hZzK8acdu2QKBgQDwgN5zkgOELSulfGDQ +x6spyjbEdN9dn/cwCpolMJMg3mdcKP/XjPTTEe1dsWT7mTa9qxjWgcxOzr1A3h4B +ZPJTXgOQyt6rPYw2WffEh6+5H28+629VlhQary7Sp5rZAXiJoHgzHpb9sURwliTL +62GzaCOxJd1AI3qd8atjgI/JmQKBgQDfpwcGmcpAhQMA/owdowCoJhQ7Jc5h3+RD +55WO6sFFxigxa+gSt6NVw3ef5TB/zKyovPGceunaMyVOeKA3RSNYNX3gKKhpugeg +wv465jGw84jPj7b1LMc7ydWHKWQ4M6JLPxlSM9lIV0Zdb+gNu64hCNMGOQljcCuh +a0Fi7XgQHwKBgES1XFgCF/UT/ospjHM5B+JJffoENagGwlS8QqtrRC04vKisoeLP +x0XhskF5I5NpgyUOk2r87AR7tb+pdUMKttwwWK5t9s1PKRaB/3HrHb2yiFKealE2 +LgotkB/oeCmU7P3MlWptS8+wbBAKJPsJBQF/N+stGRdwy2ACIeesW+fJAoGAbG6w +i1S4qDtUz4CaMiw7P0rm+B5GR1GjfACllBrhBZEjH4Lvi1OZTxVrxAv8TZnQBCdH +BNTa2D1/0uHM278becLFeo57yHa3CAxB8hB0+xO3uto0m/3Pwn8ClXtN6amu/8hh +4Gbe66HUrax5116s97sthJDWqm1R2fsEQpBba4UCgYEAitrHGT/Kr/91Ttccc7Ww +Eee/xEJR8iMFU010zkX9MAu1JExXOaMWVJRWlzSIJFhDjEovaq9qxdWPsoDT1C/7 +JIs7RGDVWX2a6uun5Oz9JJJ9KmNBzOAicTBBrWMT67TGWZhVYjEN9PvRyX/kMssP +yqRcbXt4Unw93950LphbVOw= -----END PRIVATE KEY----- diff --git a/test/configs/certs/rdns/client-b.pem b/test/configs/certs/rdns/client-b.pem index cb51b3034f..7ae4f85b76 100644 --- a/test/configs/certs/rdns/client-b.pem +++ b/test/configs/certs/rdns/client-b.pem @@ -1,20 +1,21 @@ -----BEGIN CERTIFICATE----- -MIIDODCCAiCgAwIBAgIUbM5eMdzKfamh0SDEqztq73kUDmEwDQYJKoZIhvcNAQEL -BQAwEjEQMA4GA1UEAwwHTkFUUyBDQTAeFw0yMjA5MDcyMDAzMjFaFw0yNDA5MDYy -MDAzMjFaMGIxCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJDQTEUMBIGA1UEBwwLTG9z -IEFuZ2VsZXMxDTALBgNVBAoMBE5BVFMxDTALBgNVBAsMBE5BVFMxEjAQBgNVBAMM -CWxvY2FsaG9zdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANRGr4bX -4RWXp572RwdncY7btEtWr0y5jNcYbyF+SmsQ1psDEUlLKXhUnSsLEIlCDuy5Rqtf -c6BBnE9MBODilEbkWaX0MBeb9zGDAAtI9oSnOtg1qpzdZcrKXW8INwuWJAfebJAt -qREWgMb/tdB19ywjpGbvILQPF7CA+mNg/9t48kVG0UEL58ZrQTNhHQUfgb4wpcVg -rj2SS0OwxJwyP8aRTWWhU9Zm/PYPySBMnhvCBC6UIlna1W0+/KSE/mivqjIPr2aR -fNuGj9Q/ZdWxtV5sE1XVTVcxx274qVFHHToWjwluHJ3UBk3rQcurh4c+bx9QXyp/ -l3VHm50bVBQ7NpkCAwEAAaM2MDQwMgYDVR0RBCswKYIJbG9jYWxob3N0ggtleGFt -cGxlLmNvbYIPd3d3LmV4YW1wbGUuY29tMA0GCSqGSIb3DQEBCwUAA4IBAQBAXF/C -7h1lIGsMOr6v0ebcJ2PHZWG4BLQEijXFqCH8HJPQGN6bZf8Mar7dqwI2OG2nhyrd -66+Sm+lMGga1qufl9NKlg999mL2oX6bYow6+LsH9/a6aNecs1utSj9yS3Rsz/ENY -CCBYsEvMK2ZbcXprM8u7W0Q4+01yDxPQUB2aK7NaG15j2lvPaUxKNIY3/2HPfCGp -zNiQRMB52PRv43Dw+bqUJick9KnI4ZmW6DlPynV3Lcbrn45olPBg/ILmeYf40ELb -1gBA+RACSOdoohtksjYO2O/NyqgS7/PScdHLn3CRNV1BJbC6xiZWAKVUVeXHBcFe -4BIZS51qMf2oP4ZC +MIIDejCCAmKgAwIBAgIURF3HIP6jjAixTsMisMxARhqRfcMwDQYJKoZIhvcNAQEL +BQAwEjEQMA4GA1UEAwwHTkFUUyBDQTAgFw0yNDA5MDYyMjMwMjNaGA8yMTI0MDgx +MzIyMzAyM1owYjELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMRQwEgYDVQQHDAtM +b3MgQW5nZWxlczENMAsGA1UECgwETkFUUzENMAsGA1UECwwETkFUUzESMBAGA1UE +AwwJbG9jYWxob3N0MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0h0s +cYMqt2HeBy6c5qUXHgkPMuKqrMrImdgv/R4cHL76FF0SbyweVc2G9e9NgGTYG3n3 +68/EURnGmmLj0V8JIrURm/zHZgvwBYtmgC5NTOBCsxocOSI8i+rX5PqmocZtCAAi +VUFvVu07PDuqHap6np71y870zZ9FFlr+42aJzqap0d+gqMSI/VhjVyJcA7XE8AqC +33fVfpFM1z8myFawC9d7Sz8qWe36cgJMHf+KmAGefR20bEAzb2CLZMHuCUIhbeD0 +PePnhg17ZA6rbSj4uLlFIEhqkc0zZL5DPigIIUQ+OVzdidboMNehhlLeLECj1Ykw +4dOskPzk0V+wsrr5hwIDAQABo3YwdDAyBgNVHREEKzApgglsb2NhbGhvc3SCC2V4 +YW1wbGUuY29tgg93d3cuZXhhbXBsZS5jb20wHQYDVR0OBBYEFBN5/1B/G8UTcl5O +tqEHRzrAJ4IHMB8GA1UdIwQYMBaAFHMfJfiA8Nb10G8rKcO/am9Ogo6tMA0GCSqG +SIb3DQEBCwUAA4IBAQAioN2YIK8yKkyn3x/UH+YhgLJj9CZfkCPa2uJTBaXCmZcv +KBPfjs4bQ/c6omLzbGnIVEDHjUEzwxUf40cVQbciPXvrVxB5PIcUY/e8RAgFux7j +YnP4F4fM4DC1yOA5AIqWZGX66GVnw7rslxz5Pko6QKNaHuVgwHHEizN0d8hHexdH +rGHtX3tsFmI7GOwsVgLJNV3VcpT+W8ZdviHtbjL2gR3N/KpXSU3FHmDC56Zi8HyA +iUICVuCo06LCEq5J8M8f5dBEMtLJ31gDX1c/arLJuS6VS/+XrC7lKNT571SXPa9x +gRmY0EtzyYut/yfG2qXWV9Xi0DbrZUKZVIUcqd8y -----END CERTIFICATE----- diff --git a/test/configs/certs/rdns/client-c.key b/test/configs/certs/rdns/client-c.key index 4265bd01be..47f9041759 100644 --- a/test/configs/certs/rdns/client-c.key +++ b/test/configs/certs/rdns/client-c.key @@ -1,28 +1,28 @@ -----BEGIN PRIVATE KEY----- -MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDjR44IbeYZR/MM -Wxyp2pJauzX59CJIib9lEmwNWW1YkIFB1BSLtCA6T+BaPiM1OqFc9oDPAbpN+vnj -ezerQLv/El0l8QVd3KsURDDNQd3dL3hhZwhmSKkOIl7gRoCksintGyO6/+miZZ02 -GrYH82MhnKLtkBEqeRxFweGtsqYFbb1cv51juLXvqyhBDAN7RBepcpA/AOw0S0+M -qalW4BbbAhvbQZdxdtrfC0yMuo6ONlsaa1/n+GG1ydqxtjgqhevZ+JsjSqZIW/TD -F7BqYt8ycU5gqmVoeN/iRxaDTRBSd/ALdM6qWBdlnrcKZvZe0ezbCn54YsIYXyvM -NaRtrftnAgMBAAECggEAQTDPDp/nNi0rC8o+iIHHJPs52j4qb0ADhAwqrhGOia65 -RJZ+Ziv+antq0LeuBaCRlEaoX7gRJjjs4FEBgL+KrPkpeq6NaYTYFXIRxW41IzJw -hw+0mxIQW5uENzRBxfvMhtQYBZVOAGTBGTnEKLepIYT6PsXqBpLCh0e7YcUyVa/A -E9fV6cCWWSb7Z7AJEw6blbhvRBsdEjXug0N9bX3KNlnOLEAVLwPhEjFMGDhYVEgb -G3QHC0DOryWJHQABayiR0xi3cQg8RhokwS71VVN3d7KvSnSreh5x0FeO/la3u+uu -U1YL8r45R27h/PAf19yHRIIn0+oFzDQeJnF1U6UJoQKBgQD0TqXtxPQkrhRKmR+g -5oRCZegDL6hBRyf5oAL9tg674WUybhw1aXJwGxUruMcm41L//Dhz6hn8eTmNbGth -k3uw9zpgNE4iT8yOAyAcmQxT+iyt3mKi0MC+I/DWr7Np1SYt7ANVNFnvWuS+Kf9n -qp6TJg902ikSb/2UV7h+DzgXaQKBgQDuKEa2RYhmTp4haY7ztjpWCR4icnvQhcKb -f58dysX5cAn2HjW7mUHjwECQGO+cjZo7qlFIxT7CtuG8m6U7YMi9MRitQBo2lhDR -09OlFQLOgaRu3h+yDJEaKTIrX344xTucfqiVo/BtvvN6LDsKqM98AunRuhc8QHI6 -g9Qe3SJyTwKBgHbLA13hRgHL76vyVvHLBQawPKfH9Z2ANwznZGzvqKxsxeNGrUq/ -cljWom23FIdxQ/ubLewXKfmdDIIa9P/mUd/T5zu+UzvV55YqKOQe+2KeJDmLCBU5 -Qm9yVHpfxvKwJTdxKpG0ugJsBQv+qeVDjoXonN1p80y2zevi15/cUJ75AoGBAKLx -LYgxxKPysCA+H49BI2KP9G0vFOVTTxWi2JPCk3cZH8ejXbIPplQTyliMpwvemiKu -YdS/FzSTeZjYiNE6Y72FpNOMYyLrw3A8VLbCzFvLuVwdX2QrUu+qNegU+sAOub1V -rzRKqQn9NoplTrP5UZQQTjeu8YzIrx636V6Af7vjAoGBAIY7TeI8Y5OqN4HR2DMH -3CCpy5VKuB4oBSxvH6hVAf01wv5ktRg3MtQrjyXuawCrfmAtf/oXKWZlg3eIuPGL -//5xetCgI+rEaD2bwIi1hWpjyTuX3yVVlwyojrSKTu6xIS13SC8YGVqvJYAJsC2i -Qe9CVI3UAH0Yo2yRufjUYD0t +MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDG0eLmkpj4R7o7 +Phx+EUuInMKkHD2yoYVIDc3+ipvj/3bptxWVcRZoWroFLrUroSGnPBI2stXHGFti +5qkCCjmsWLsido8luDsLnr9kBQafBoV+tj+u/ZkJSeTJ+bVXaGS9GR4rGvYPgwRD +dyuebRSrqW/GB5Chp0X4JqxNGrX+SrtU4fz23eBpg1+Tv9Td3xhlw4FdVAphSYS9 +NYLg7fNpIVwXLcvyXgLya2IOvItHGM1TyWq4jsOrgU23z640GzTUEIic34KkgF78 +Be3ZN+0oEiIrojpUb9I0k52NhHL6Jjxu01/IIgan4n7h/tr3O44YOeNfpRtn7RSA +CelkiXUpAgMBAAECggEAAwbQ7cek3Sq3srfYVob237vbLq+2ChEcEU5nKLfSywlp +iwHxfyvl4RgjJXm3jP7P9KwdGYi8E7goM/zk7RYGGLyPug+UpZ4EsBbuPPHipEBv +fyVRGjMxcDXCw4cHSVmv0ZJ0ph1Wn5fT/x7s+BAbCh3zM1A21cR7yTJK2dr36Ei+ +CgUEvVJQh3rult/4JJ5E74oXq6rXRqAjO7i/DXImLiV7YePjixhy4YGpYH8T1Da9 +CdhA53Ec2wqcEfaIZC+fMtz+4XQnCOJJEjJGfGApGadu52sqA6dB0I0D+DWy3H84 +V4MPrJMvllK1GH3pk5zqm+tWlt62R7hc9O4a7OOVgQKBgQD9ydnmPv5Zf03UAzT3 +VLuwvM+5H1EthWV0CsjPf9M5QGfAm5tuxrqWRfZ4mPX8YRJFc0RXBy5WD+UkBwDo +GvmmD96t6FJ+xsXTz0Oq58cUAWiyuqPldbe+NdOIHasam31jBss/jrL61YHU4eec +tCtTZtJQsvQ/X3wjWSF4fOmaOQKBgQDIjWlmxnxC+AhdrtlLYVhg87NoVgAOAZcf +MCnJT9xMbhfmZko75vUdT4OnTXVjtxfqLP8yZE6lgb7GaTum3YLhhfZjnRs3buGk +y+6mKlNNhfrOFCw8tgVzaeGQi+dE0WyBHqBpiKxU6EixY/28oV1+einxu9agZCNy +USU03LdycQKBgQCkSdwGAfdzhkainaTXC4IpCkFKLKzHVBh2A1k1giEBaeEAPXtk +Pb+h8g54yURMKabDULgHwn1LdyS1qtb6aiP8TT+wwrlMmm6MDBtY8ovcNoFJWisp +KohU2NFjxxjxs4B673X5Ye4ZFMfkQI1H0xZM+j3hwcb9k1lwJI3XSr2KeQKBgEUA +AkeN+qq/04EH61L4BwQ0VIGNNS+cdHYSiA3vIAhbyHVItDmv2J1hAhbJm53XHK9B +E/wubrCa1xxEkHV0uNcG1CKppveHerLMRyt8XHTLp+LHJgEtTurKfwTQXZ1bwE0c +UGx+zWvZD0mY8W+4xQYC2fOFgO5mBZwLNxXc6nDBAoGAHJaD/ZSSjtAqQnBYN7Wt +/QOpWx3UrZ4xAKM6KPp0jAKNHgFlH1j7KXIT+fC54TdYw6K9TOzMOG83BFNBs1vf +GTRc7NbMW5fW5NqLEwqBK6lWChqXMwjmz/W7qxRBPqtsmAkubgUO1fBw/XReut7C +XOa0n2b/bfIb5jCCFAH/Gw8= -----END PRIVATE KEY----- diff --git a/test/configs/certs/rdns/client-c.pem b/test/configs/certs/rdns/client-c.pem index da060d5ad4..190c7b9f05 100644 --- a/test/configs/certs/rdns/client-c.pem +++ b/test/configs/certs/rdns/client-c.pem @@ -1,21 +1,22 @@ -----BEGIN CERTIFICATE----- -MIIDZTCCAk2gAwIBAgIUbM5eMdzKfamh0SDEqztq73kUDmIwDQYJKoZIhvcNAQEL -BQAwEjEQMA4GA1UEAwwHTkFUUyBDQTAeFw0yMjA5MDcyMDAzMjJaFw0yNDA5MDYy -MDAzMjJaMIGOMQswCQYDVQQGEwJVUzELMAkGA1UECAwCQ0ExFDASBgNVBAcMC0xv -cyBBbmdlbGVzMQ0wCwYDVQQKDAROQVRTMQ0wCwYDVQQLDAROQVRTMRIwEAYDVQQD -DAlsb2NhbGhvc3QxFDASBgoJkiaJk/IsZAEZFgRmb28zMRQwEgYKCZImiZPyLGQB -GRYEZm9vNDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAONHjght5hlH -8wxbHKnaklq7Nfn0IkiJv2USbA1ZbViQgUHUFIu0IDpP4Fo+IzU6oVz2gM8Buk36 -+eN7N6tAu/8SXSXxBV3cqxREMM1B3d0veGFnCGZIqQ4iXuBGgKSyKe0bI7r/6aJl -nTYatgfzYyGcou2QESp5HEXB4a2ypgVtvVy/nWO4te+rKEEMA3tEF6lykD8A7DRL -T4ypqVbgFtsCG9tBl3F22t8LTIy6jo42WxprX+f4YbXJ2rG2OCqF69n4myNKpkhb -9MMXsGpi3zJxTmCqZWh43+JHFoNNEFJ38At0zqpYF2Wetwpm9l7R7NsKfnhiwhhf -K8w1pG2t+2cCAwEAAaM2MDQwMgYDVR0RBCswKYIJbG9jYWxob3N0ggtleGFtcGxl -LmNvbYIPd3d3LmV4YW1wbGUuY29tMA0GCSqGSIb3DQEBCwUAA4IBAQBbLSVV7LF/ -JtPUKWQWVvHgyCnTLGQY9AUMcUNO01kCGCz6JeIKfcOYMjtVB6UvdzZr+JFK2fL8 -4EN7Hy8XfPpqxcvAd6GbOlzWkfaMjx4xczlfcc9O9+ZlTMEJLHBweOu69cuDllrJ -FsMc6VlOeGAGWsLFye0TECgLibrGdrK9rC42HGBvZoA4fV/LP3mcKX0+yjoT+LP0 -kZ6nm4LJ8u0Ja17Ovf2jkjFkl2NnIzk3/UpWBVaUO9fXmmTuIcRpvG/nrdLvzZIs -nlH5b5jtlmumnYmJlBy1nb7T3IDf8Aigw5wIG2J4qkR8FDZkDNAfXPiHMux9cj16 -aFpSCGqrjATe +MIIDpzCCAo+gAwIBAgIURF3HIP6jjAixTsMisMxARhqRfcQwDQYJKoZIhvcNAQEL +BQAwEjEQMA4GA1UEAwwHTkFUUyBDQTAgFw0yNDA5MDYyMjMwMjNaGA8yMTI0MDgx +MzIyMzAyM1owgY4xCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJDQTEUMBIGA1UEBwwL +TG9zIEFuZ2VsZXMxDTALBgNVBAoMBE5BVFMxDTALBgNVBAsMBE5BVFMxEjAQBgNV +BAMMCWxvY2FsaG9zdDEUMBIGCgmSJomT8ixkARkWBGZvbzMxFDASBgoJkiaJk/Is +ZAEZFgRmb280MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAxtHi5pKY ++Ee6Oz4cfhFLiJzCpBw9sqGFSA3N/oqb4/926bcVlXEWaFq6BS61K6EhpzwSNrLV +xxhbYuapAgo5rFi7InaPJbg7C56/ZAUGnwaFfrY/rv2ZCUnkyfm1V2hkvRkeKxr2 +D4MEQ3crnm0Uq6lvxgeQoadF+CasTRq1/kq7VOH89t3gaYNfk7/U3d8YZcOBXVQK +YUmEvTWC4O3zaSFcFy3L8l4C8mtiDryLRxjNU8lquI7Dq4FNt8+uNBs01BCInN+C +pIBe/AXt2TftKBIiK6I6VG/SNJOdjYRy+iY8btNfyCIGp+J+4f7a9zuOGDnjX6Ub +Z+0UgAnpZIl1KQIDAQABo3YwdDAyBgNVHREEKzApgglsb2NhbGhvc3SCC2V4YW1w +bGUuY29tgg93d3cuZXhhbXBsZS5jb20wHQYDVR0OBBYEFNZnXD/At0QIFoqsEUNn +hd0XqkJWMB8GA1UdIwQYMBaAFHMfJfiA8Nb10G8rKcO/am9Ogo6tMA0GCSqGSIb3 +DQEBCwUAA4IBAQCiIEr4+IiHo4PLK41l6Yuo6QKETZg5tNKluqkT7r5ulYaTss+C +O7nBIZaVAK3h5+uRTzrL2mEUyme4tYBUaIxqVTnjDgIbeKvg3Z0k07Zld7+eeE/B +vnPk3c4aZaKshcbKoA+tZUeHk+BYZ28YkDH70OYsyVhemvTVDDy2EZGdgeaWJAbx +RcQ7iVAIR8SEgJy9PWZMAFChNxa2N7Q1AcEqnU9UV0+XOHVHe+PYgK7SfuNOxM6x +rP2NnkLenDoZ7IXEvl2WYVlnJpIZiNTRz94nkTz5MqjCuWS+YGYlPz76gpGPJ5NT +VEfAZXP0EW8NWJ1XEIM6+u6c1SWnSJfTt6im -----END CERTIFICATE----- diff --git a/test/configs/certs/rdns/client-d.key b/test/configs/certs/rdns/client-d.key index 96175248b8..421bed9db6 100644 --- a/test/configs/certs/rdns/client-d.key +++ b/test/configs/certs/rdns/client-d.key @@ -1,28 +1,28 @@ -----BEGIN PRIVATE KEY----- -MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC8d7oinhq3ZZgE -645bhTe0RxAbavBEU8H2p2acdPl5/yWA24ytT/wxIyk5pyAaeokGh5JiAk2Wag8g -B9zuXWq5xUCs3e4d9LuBu2KOL818L4D8TFbOd6DI5MfHIMMeXWyxIWplFtOIeTE4 -pZo2h0MjWi69IDQDIwfGBXoBpGREa6nEp466E+wHELYM+N466ETZqlupRXjSc1ry -cDVeEDWMm0tI6TD1lMm9C9fhC6gQ3x/qvADHTh3TeMP1jfoqqs1xK9sAcXPL2m7Q -aA2VxJlYE1Goof1RF2hdrQ3kFchLPn6nVbgOIklVN10lMuGADyhh0VkPeMdQTLuW -ir4MbCQVAgMBAAECggEBAIhyxjg5723IB//H6xEnqeTDbk3rZniRi2RgXlH3/obs -yuI4EemIdzW8FyS+cue4v2wSy1BaCoJT1w+BodqRl6tXvDNrmfHmNbr/R6NZyJOY -cPI48sAYrDfGKz1n4twhF4hGgRkfJZcw5wn0G2pPE7SMnjofDokW25HqdSKrOkyt -xkqC6wC3CPQUgNagmq5PJE3syTa2+66uE9p8jQ8k6DIxHUCqQoGtYXQX4zSgha/q -otn/Lvpj++pEU+tSHDAatdBQjWmx5qynIHXG30Cp/jRBvcEcMd76z56O7R5bOrZI -9Kmg4J/3PuuXV2/Yik3cQ5M3I1UL42v7mC1zEtXUhiECgYEA80+KH7vqvb2/RXWR -/jGhwvHjkWX10WPVzCHBJN7ItRW30GkqzjNSW8SQRQsA62+AQomavW1StCZESzw/ -guVg7J6d5PNcI015jVbNT3Q6rYRntOlehCuRHmPwzKJkHe8I3V9+1gEGAY3yVKzr -FUvJZrQB2Hhwi69pOcDhS4ur5lcCgYEAxkv5XNhAshbq255t/W+l+FFC2GbKRG2+ -Id5dRd6zwh7JJ0z98qSmdvDK3iymadddpCnTvKyfkixGkRHYM6pW1p6jYdw59TYt -tHkA+APhB8NEyX3negkvMYmxJGUsEfF9nCxmpZ5Px6e6Ey287jms858Ty0hZosnx -Ktr/H9dAzXMCgYBg8FzIvfcNt87AHtKW4zFe2T7gzC2/SjaBSSWJyhVPSKLerzf1 -xa7Xjx4n0/V+2ALS/74eILNlwSVOkGeBgGA4hg3EjU01Z4W5UU8li9phDbK/+obE -xBLid9EVxtF6t6Thhk2jd+7rqaFWKTrUVkic2bUuiPXWQYH8F6PrlG9dqwKBgDBg -1rydEeOhDbl5BJKhS5eyk6FiKpTZRVrT+mOSer6wbhkFgqtRGj/IbWYY9Jy761+i -yMKuRtwNq0W3Wcz5EOiZmXjFlupJRotSPjdEEwGm1UBnVDMEzJvEYRBlEoRqK2AP -wRdE8Wffdtk4/nAMaDKjq9ubkirSI+F1vmqRRIEbAoGAdjEEzMPQAUXNWJvbQkrF -8Mr4R+Sl784IsA2bGbro//g5JYjupvNMLobkqsPIMqYqkyJShZAmE0hOWDSzcKTa -C0Ti+OvFytoqw9JAJhrkICI++OIa4d9ThssOcGyj+V8ZVRsddN9gWH8rdt6Q2WiB -QkbuohwlWNKi9AdVuPT3xJY= +MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQCxkPAQkDuzNvqJ +/iVOuucGi7n2N3VI0CXBoAIUTlyWnf73m2VOjeXUCBL95so3uGBd1Q+R9BwEnPH3 +w8P7zEn007tryzskGywjEqCn2WYW3TKBGuFhuTc5sFE4IesCjglRwebsCn78V7kE +Rnz9/hRgULEIRPjWZkdwnxO03S/4n/lzMxCkZdLjyIWpr99B9l5Z3dAFlMchRqKK +7+IJGorNjEIkVLQIHdWFUAnI2ZBh0Xkuebqxg061dhEnvo8aBi/gqcc/8IVfnUbX +mmQM4nPwRFzOY1/+hfCKOIR1MAQZ7ydXK1C0tuoR3rSvUEPgT7MbAoi8PZIaoLCB +bFDsQ0LjAgMBAAECggEAGDmobvIRRbWPVTVDB2yQvqq1z8V9hFYVg0bzvFZ746FM +RaFsnwd/9BS36+5JPMne/TOSFhJiTNomruwFTdHvbcNXSMZnhq5dsAPyFC72R9Hy +JSgILhTJV98EwwOUSaXG2Ax8F0xP9S3N/wB+PAl749oOamI9OsRQedPSKfTv/wYw +zPNhr4MgnnD34VDnkoYTFIU/n9OKeSgh8okx3PFaPkfYKjaOoIFHA4j1lMMVa7kl +q27MrL/vpWF0MUu88ip3lDmZQC9t6BovoIidwRhNEYo4Qf+igcwcIce2MY77gg3Q +IvWpsG7r/jyr6KFRONvyJWpyIgAq0Y6aRb4cNzkDxQKBgQDWrOdLVg6xw+I8BVrM +9gDJyfeF8zEXu6Mi3zrypyOOd11ZqlVFaeq/sT2s7HCVEZOiqTgWE0ueBry6FGX3 +DkzGpTo1+kd5HiKawViPHnIIVTV/F1Hifrx8bDHRRPVqyh/iTV2c4S8Jdf90zgZJ +vW2wErGTrpTVvgnb5GhZBZIQbQKBgQDTv082UDFD3fpA98t7DptqmYn8hpdAa4Yy +MFMHBNbNntB5G4RDdDut0eWA01MKNRjKrxBw+YjuOgTIRx5oVre73y83932rGSiQ +g1/y4PidwPVEAnVbbLqvvHkkKTbBbHENSh2pWCikJhAGKhVI665bAc84o8o4ikN9 +IQ20TUqujwKBgBt1rHRPgrusYcDpsm6rPPiS1A2XSP1PLBPm2AR36q1riU5R4mxp +mvSAOHJpIBGBWRAicyEnwLFrDTMELvLGKn3yXprO89uDRkvjVW+hJlb4h0pFclz1 +dyi3MjwhhP7u8dshqErL5xdft5h6TgWarHAsQ/ivCSy6DUrKUaqpcsCVAoGASq8A +Nkzkg2ZonL+JYlbNlDShSZMDB/Kku1D2B9S6Gn34U67T4KK/ZdhRVTWz5TbDDsHe +T6qDlFqcUzNaUzy6wyW91sSQ62cNOqNLlTOqHKHxH9KqJ9vaoJ8eLxXmPSSNXz2T +5qW0d+kA39u59CVEMs8ZkoWajoSdtyWQWtakD5sCgYAUgWP7Z0CbUeNyaH811Aef +/P7inGoQEqTYrmnyAFmRyBnmq3C3OjTRiz7+R7cERpgVVmLt4xpNWjmTbcngfvau +c2YViXlsFx9s/xXFQBtppmdH1WeZBIOZbN6EaA5q0oHGOXAW5SmZR3sGKeG5Mz/m +VDNDxg7Fspw4ZdHu6IeOCg== -----END PRIVATE KEY----- diff --git a/test/configs/certs/rdns/client-d.pem b/test/configs/certs/rdns/client-d.pem index 589a920825..ea3cb0be4c 100644 --- a/test/configs/certs/rdns/client-d.pem +++ b/test/configs/certs/rdns/client-d.pem @@ -1,21 +1,22 @@ -----BEGIN CERTIFICATE----- -MIIDazCCAlOgAwIBAgIUbM5eMdzKfamh0SDEqztq73kUDmMwDQYJKoZIhvcNAQEL -BQAwEjEQMA4GA1UEAwwHTkFUUyBDQTAeFw0yMjA5MDcyMDAzMjJaFw0yNDA5MDYy -MDAzMjJaMIGUMQswCQYDVQQGEwJVUzELMAkGA1UECAwCQ0ExFDASBgNVBAcMC0xv -cyBBbmdlbGVzMQ0wCwYDVQQLDAROQVRTMQ0wCwYDVQQKDAROQVRTMRYwFAYDVQQD -DA0qLmV4YW1wbGUuY29tMRcwFQYKCZImiZPyLGQBGRYHZXhhbXBsZTETMBEGCgmS -JomT8ixkARkWA2NvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALx3 -uiKeGrdlmATrjluFN7RHEBtq8ERTwfanZpx0+Xn/JYDbjK1P/DEjKTmnIBp6iQaH -kmICTZZqDyAH3O5darnFQKzd7h30u4G7Yo4vzXwvgPxMVs53oMjkx8cgwx5dbLEh -amUW04h5MTilmjaHQyNaLr0gNAMjB8YFegGkZERrqcSnjroT7AcQtgz43jroRNmq -W6lFeNJzWvJwNV4QNYybS0jpMPWUyb0L1+ELqBDfH+q8AMdOHdN4w/WN+iqqzXEr -2wBxc8vabtBoDZXEmVgTUaih/VEXaF2tDeQVyEs+fqdVuA4iSVU3XSUy4YAPKGHR -WQ94x1BMu5aKvgxsJBUCAwEAAaM2MDQwMgYDVR0RBCswKYIJbG9jYWxob3N0ggtl -eGFtcGxlLmNvbYIPd3d3LmV4YW1wbGUuY29tMA0GCSqGSIb3DQEBCwUAA4IBAQDB -uZdw5nPDR/StWzuYz87ZCjeL7mWWuLYGSQr7H4CMDc0OWf8mkfYAHTp42IlEmqMi -mux+wxgVeqh7/jOsry5TXO6Sleoy/Blh8Z9bcMpnDDyB0+mI+bSq3LuPukI6LJ6c -JNS/NclV4tB91t99kCp58Eeh5p1Ro3sUgpOdb//JIAmWee3m0fGV421PGPHMbZu5 -Kv4jLklV7KpzSDGmB+fVUz4vC/maV1Aj6sIUX9N8YrCfZ9h8R6JohDBOn1rd3rgK -ubqOhHnYxa2dS93TKSISF33Jvhim94yQ1sPX+YgAhGUeoXuwbr+NQYbrJuaFFZtX -Bw0YKF/32sIciBZ38BNq +MIIDrTCCApWgAwIBAgIURF3HIP6jjAixTsMisMxARhqRfcUwDQYJKoZIhvcNAQEL +BQAwEjEQMA4GA1UEAwwHTkFUUyBDQTAgFw0yNDA5MDYyMjMwMjNaGA8yMTI0MDgx +MzIyMzAyM1owgZQxCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJDQTEUMBIGA1UEBwwL +TG9zIEFuZ2VsZXMxDTALBgNVBAsMBE5BVFMxDTALBgNVBAoMBE5BVFMxFjAUBgNV +BAMMDSouZXhhbXBsZS5jb20xFzAVBgoJkiaJk/IsZAEZFgdleGFtcGxlMRMwEQYK +CZImiZPyLGQBGRYDY29tMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA +sZDwEJA7szb6if4lTrrnBou59jd1SNAlwaACFE5clp3+95tlTo3l1AgS/ebKN7hg +XdUPkfQcBJzx98PD+8xJ9NO7a8s7JBssIxKgp9lmFt0ygRrhYbk3ObBROCHrAo4J +UcHm7Ap+/Fe5BEZ8/f4UYFCxCET41mZHcJ8TtN0v+J/5czMQpGXS48iFqa/fQfZe +Wd3QBZTHIUaiiu/iCRqKzYxCJFS0CB3VhVAJyNmQYdF5Lnm6sYNOtXYRJ76PGgYv +4KnHP/CFX51G15pkDOJz8ERczmNf/oXwijiEdTAEGe8nVytQtLbqEd60r1BD4E+z +GwKIvD2SGqCwgWxQ7ENC4wIDAQABo3YwdDAyBgNVHREEKzApgglsb2NhbGhvc3SC +C2V4YW1wbGUuY29tgg93d3cuZXhhbXBsZS5jb20wHQYDVR0OBBYEFM4b9lmfPrfM +tHVxnMbxR8oyE0ZtMB8GA1UdIwQYMBaAFHMfJfiA8Nb10G8rKcO/am9Ogo6tMA0G +CSqGSIb3DQEBCwUAA4IBAQB3O3Q+oTfAVitx8K4+ZzXILszfblsGO4kvwvxV6EUB +BUsat6mjawFTGhB1TdBR0CflA/nCjTZpoXNY+nCoJmr/Lxk1V+UNn5zhFTTfhZjU +PA+++5QcYxXz3ukCEqTHLPZKvv2xB24xQUmsdwLlX3VGE1VqBfaz/2x6jFTVT3lz +4W5JPltgFSVOLqQC1T0MY8L0h4eL+JpynHPjMkEwb0U4RPaSBhiRSjHD8dgoZ8Ft +ZbV6WCJeBYey0edKNwujuLl+McVpx6DIy8BPGPEcuo20Sy1BP3JAoN1Wu5J3zLBA +AXwUZ6r7jAjU5v1nx6ijwtv3qavBVdclOlW0aDu3+Y3z -----END CERTIFICATE----- diff --git a/test/configs/certs/rdns/client-e.key b/test/configs/certs/rdns/client-e.key index 69971ab20b..322bf5fdba 100644 --- a/test/configs/certs/rdns/client-e.key +++ b/test/configs/certs/rdns/client-e.key @@ -1,28 +1,28 @@ -----BEGIN PRIVATE KEY----- -MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDUSCUDUyDADOnu -RRMUjWhzlCRbe7rHHuYnbqmQPNMsmgp85+GqwTHVB+B2G/1/BWcpThEDPM58ruqa -Q0NVgWN0KP026YJa7XZvlOFFrCFukWuHYAhieOAYrskycGHoyIgTgsiZPDirA7hi -YIIZktp7e4BUH04sDPy0SKRWdyB5BLH94cN75aIXLSzrU9Or8Yb+RWlgmiZWyyQh -k40ybe5BEMO/rtk1+SHtwwBpmkZ6If/G4lUQJb+FHzWSWFkuTkTag6sI6XapmVg1 -Ht2fuvnRuIecOPB4rQ7gjIVZYVPq0+s2hngFewJWVntzjsE8zhJ154PSMFtGKP/d -y3HAhBafAgMBAAECggEAA8yqxO1295kDkt0voz2IshDjubN0O14lNm13oXpFOVYk -e+nWkyzUDIEQlmyX0+8v0oBwM4OiGn8y+cHccapYMlsNdS8mwyPe685ZXdrf2k/G -Ae1JGSIauLZgKYPzbKwyK0868esvBHiTk0cw7O5A9NbYDClnR8iPuVZXgqitLx1L -BqwHXv7KWLU6nvbnzPfnA5DK4+7Lrig11AEDMDNYhb8YkY+Gk/HE4Uznnk3Y34no -khSTVu3nZve3QAtRr4lUlttqOog/i35a815leczjpbmwB4qAX1YKJC+AQw1ZYzfb -SFHt5f+OOrZzDwp8cmxQMAcvmzXRbDwGjwn7tRxJKQKBgQD9L4l2AhCyjG2D3xVe -ZfD6UgYHC4r748+/sQSXUsF68WGC2zbrtvc05wevBX2SuUcnZt7Hncwna0DjdeiP -+jFXjYk8RQwD4hAZ0bIR/ESOMKlG8uJEV1b0yedgwHoJY74Gwk8IyAnTrmrLWJw0 -QUL9KOsAFop3in4Y9irWWpVr5QKBgQDWpDY/SOjwhkIZLtRxX2IbvRg4DYs2dn9u -3l6vxV4pTnVZoQKzVzYf3KhZM8dUg8tTd41kFqJqTEHK2i8+pnggHE8XsoUK86Sl -Pc+xn+QZb3Hzyi1xdUUxZDMfPRuS3F2V2P+8E+Bv2i/UcehnrsYYEDuqtlFKg7MF -qb7/jTe4MwKBgQDW7osADgLEwCecIj5Os7WdmxIY2viymxNaxNiD6bHsP4uq/ZOj -CODVHSdNshiG/RhlX5PR26ha8lbUgdzalOdcTv/olSj9BuTqNjS3xfMgzjh1zWy9 -3XMpPVlZriwrWmwP6tYTO1X0SIXKeD+qsJhAt4K/wWLs1jnz0M5Ox/k+7QKBgEDK -qxFpad+JN5SwfTKH726eIxxwgjB7jrYh7AU1F9pyM5xNrSoDznPJwQvERIxviEX2 -1bh72KUrxcR9HjvUNnjC8uEdY2nN6Ep1ISfmMw22hXho9FTGaI+jRodMg/FOEfX0 -3iWg/mPlQgDoLZZ2vJdw9wHuLRXIMZcpCV3M/B/fAoGARrRirSaKmEhv0R4lRfjQ -eqgiXYmFpFqHfhRnFH67ZqRZk6bezPK1Z6aZQP4/37v6tPbA1uJUq1D8LvQJVWoE -vUkHlA8iyhnehkutvyYoHluD1TKO7gBqOAn3Q9+lssA4EU0anfasto2IkYMtBBJQ -pjg2LTF6YY7tbYNMIwHvX0I= +MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDRoOr56ToxIMnw +palVuFJwDnPotA0toHmQe2+iGUtsOaDQW5USKynV7YrP2DkBTzai+KyoA6cW6b3M +i8FIivJk9hkxnWp7CuSn0dFZVoyMwSuyelw+ff+8Cn6hNmg9s0BgQklk6pe5LsGh +Rwun6CNPnlJapYycwaH3e7W4fiFrs5njz4yrYQTQZPA6fBybtcT5NatPMWBzCHl9 +HoBzLWEOphN7D+Pa5Cx0zwqHf8h5/NJUWXnNO89/Kca9oGZOm6t2+Dk0OYa+nw1s +d1CWlzSYobilQiEEiYLnPgRLoNiJt7hDZqE4ubVcIDptN/SfiOr5cg6aao2Vdb0P +iNcKn531AgMBAAECggEAJj6R8AMtYy4kuXs3wBRPMfNpESDcMKFQ3Fuwu6WavYVs +AedbdIOcb9OVGiNMDyGZCbWNpl94OfVt86Xhnu7+lw3Q/dzGwujzW2yroX1pSfqq +ErdBIgORxwgxHw9SiEMuMQGW60rjYF0X5WkVRs5StuFfC/udAjJPbtvKhPy58zBu +C2ZtcZFmf4KuwzCkZT8K8zvEFcOOXNIhtKMdPRSsbO7EpWn+J3SA+mG3nKo36swe +6EptIgFo4Z0dSzS1xK50iNOw10dKgxOSJpDjg6vH/cGduUxGvGWW0kiV1vD0ndUU +U1qyQSwlfFfFUk9WrtxoWFCXgZWyhoSONQmG9eRlgQKBgQDtLYVNIKK4n/TEiz9s +BtkFmh+ohQ6vjorjkzrj88Szxy9MivCD5vvU2Q61V15H9255RxgRPZ1lczGP++N2 +IckY+iC4vmeEyKOyFX8XYaJILEXPRkoyj6/PMyS8eWciZ08QW/bhOEDSiIlFrZ+4 +C/0KfMaT3MHRFRNV+jlza2RzNQKBgQDiQ7W+xtCqsvSXbVjPrC4dmxXlo1B/O4P3 +KsdiNoGpzu1I9nfKNKlfwfnzI5vtk7dS85kZPuCQ18fOQ7aO6w3VReg91zoEDSAV +GSJLVHeiRr+XOBCV4Cpy3PloYD+m2f4niT/Ru6CfEmHq6IoouWCqSobZYlkIHtAe +Rfjg1b8XwQKBgQDU8e7iDbArZWok4QTjX86QKg3MhxJlauymYPUZ3y63XtnHtmM1 +ejiWpP+Ar1217aChgMRKDnD3uhJAvR4/XRwpscGZPVLCNEZMyOIfwwgqFp3i+K/7 +b2ig9sE/+xwvFmQ1QuyIz7HblLzy820YmKLrPJYqAaV+rJZ8tjnIuB4rFQKBgF69 +PS9JbfvbfKCfD229SX3p/uwtSrpLgEEQ73VHH1mrpB1F3fiTvkuzG+ZbhaGflUYt +a3BvrHXZc/cA0ULcVulzIQAry0YA/Or4oCxsjL8s4nH97qvitcNslR3IFz7Uzh9d +z5QQ/Ps+JjPG9HqCzF/hXr9M97x3smrKn5/8v8vBAoGBAIRJPSik2ILc8V/1FnPa +aOfcBJwcuKdRJ4yVWiwe6meQCLWBva19rH8qx/D7h+r96a8OlSDZuYltM/UF5rV5 +lEKUs7uH9Xqw8QMMI17fQ//aRx265PJvdLtoO302IUQiC5qZx9YZKSLIzetVEapD +SfKVumS7pEPZgZI6WD5YoahG -----END PRIVATE KEY----- diff --git a/test/configs/certs/rdns/client-e.pem b/test/configs/certs/rdns/client-e.pem index f17feab976..61967a7b66 100644 --- a/test/configs/certs/rdns/client-e.pem +++ b/test/configs/certs/rdns/client-e.pem @@ -1,21 +1,22 @@ -----BEGIN CERTIFICATE----- -MIIDXTCCAkWgAwIBAgIUbM5eMdzKfamh0SDEqztq73kUDmQwDQYJKoZIhvcNAQEL -BQAwEjEQMA4GA1UEAwwHTkFUUyBDQTAeFw0yMjA5MDcyMDAzMjJaFw0yNDA5MDYy -MDAzMjJaMIGGMREwDwYDVQQDDAhKb2huIERvZTEPMA0GA1UEAwwGMTIzNDU2MQ0w -CwYDVQQDDARqZG9lMQ4wDAYDVQQLDAVVc2VyczEWMBQGA1UECwwNT3JnYW5pYyBV -bml0czEUMBIGCgmSJomT8ixkARkWBGFjbWUxEzARBgoJkiaJk/IsZAEZFgNjb20w -ggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDUSCUDUyDADOnuRRMUjWhz -lCRbe7rHHuYnbqmQPNMsmgp85+GqwTHVB+B2G/1/BWcpThEDPM58ruqaQ0NVgWN0 -KP026YJa7XZvlOFFrCFukWuHYAhieOAYrskycGHoyIgTgsiZPDirA7hiYIIZktp7 -e4BUH04sDPy0SKRWdyB5BLH94cN75aIXLSzrU9Or8Yb+RWlgmiZWyyQhk40ybe5B -EMO/rtk1+SHtwwBpmkZ6If/G4lUQJb+FHzWSWFkuTkTag6sI6XapmVg1Ht2fuvnR -uIecOPB4rQ7gjIVZYVPq0+s2hngFewJWVntzjsE8zhJ154PSMFtGKP/dy3HAhBaf -AgMBAAGjNjA0MDIGA1UdEQQrMCmCCWxvY2FsaG9zdIILZXhhbXBsZS5jb22CD3d3 -dy5leGFtcGxlLmNvbTANBgkqhkiG9w0BAQsFAAOCAQEAbUkicO9FzKGqINcFKzio -wtpxOgtYmi1Ib96ti7K160DswPKNkKMFAw5eBFb0ntFdKz1KqSEvdYm04bFExQH7 -ngzZZ2LKsLPPO5gLU3BnX3EhqUqk63lYDKJQwvDv/bpWBE9GfK+kWLhrZDntCS1M -T8STpMrv6h4nTXrN4UEdK+xsatdJU3zOJ50Oi+9CxR/ZtwnSnWXqFyt0MzX7laIs -uNTvOlDgIR8GcOKnuc/Jgsi0ye0UbIXs9vEpd6xh+WRudCs7AMDWM58UA+r8zAH3 -DjYpa/Qin5UclEXnJqts80151/Vna79/4yJXw48oOoPqg/WCRWPxV5NpSKGPL4a6 -xQ== +MIIDnzCCAoegAwIBAgIURF3HIP6jjAixTsMisMxARhqRfcYwDQYJKoZIhvcNAQEL +BQAwEjEQMA4GA1UEAwwHTkFUUyBDQTAgFw0yNDA5MDYyMjMwMjNaGA8yMTI0MDgx +MzIyMzAyM1owgYYxETAPBgNVBAMMCEpvaG4gRG9lMQ8wDQYDVQQDDAYxMjM0NTYx +DTALBgNVBAMMBGpkb2UxDjAMBgNVBAsMBVVzZXJzMRYwFAYDVQQLDA1Pcmdhbmlj +IFVuaXRzMRQwEgYKCZImiZPyLGQBGRYEYWNtZTETMBEGCgmSJomT8ixkARkWA2Nv +bTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANGg6vnpOjEgyfClqVW4 +UnAOc+i0DS2geZB7b6IZS2w5oNBblRIrKdXtis/YOQFPNqL4rKgDpxbpvcyLwUiK +8mT2GTGdansK5KfR0VlWjIzBK7J6XD59/7wKfqE2aD2zQGBCSWTql7kuwaFHC6fo +I0+eUlqljJzBofd7tbh+IWuzmePPjKthBNBk8Dp8HJu1xPk1q08xYHMIeX0egHMt +YQ6mE3sP49rkLHTPCod/yHn80lRZec07z38pxr2gZk6bq3b4OTQ5hr6fDWx3UJaX +NJihuKVCIQSJguc+BEug2Im3uENmoTi5tVwgOm039J+I6vlyDppqjZV1vQ+I1wqf +nfUCAwEAAaN2MHQwMgYDVR0RBCswKYIJbG9jYWxob3N0ggtleGFtcGxlLmNvbYIP +d3d3LmV4YW1wbGUuY29tMB0GA1UdDgQWBBToYUZkIK4kXJRs9Af7V10od3oJiDAf +BgNVHSMEGDAWgBRzHyX4gPDW9dBvKynDv2pvToKOrTANBgkqhkiG9w0BAQsFAAOC +AQEAKMs8gDYeTAITUMJ2cfQqU2t1I7DGIt4eQ/bJ1LWOhC6eUXpUrwjjNo4pq95P +cct0haleycD4vjZF4/Jv81oSIUsGzQ8r3LZhJlPnzbZzaA4i4Tpxnw8JRE5iiF+z +lm0Cl783Nh8voVKE1uJrSx+pMTH9Ihwu7vBklNI192zLPLPtDFSZ497oLVt1e8Wt +2urYXF4/Wb1pyGL49gp/eOAEpw2j6pyxGSK/QyXyvvPnDLqNXJCOTyx7YQRvZnBy +h9vTtHg4HSKmgrOHA/taW051lh2PQbi3pbi+ik3rk68QY/Y7b3fKjc/6lvXPRoh+ +94valHgOVFJaSG+Qil0A8i6bzQ== -----END CERTIFICATE----- diff --git a/test/configs/certs/rdns/client-f.key b/test/configs/certs/rdns/client-f.key index fb0870d8e2..73e026cce0 100644 --- a/test/configs/certs/rdns/client-f.key +++ b/test/configs/certs/rdns/client-f.key @@ -1,28 +1,28 @@ -----BEGIN PRIVATE KEY----- -MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDhVtt98tvLqh9Y -a7y1J3AsETrmnQiInXNA/DtlRiBrhItwIEqP+O7q8FpwFZk9smo6O6zUgl3xiM41 -Hrj58oqI9G/t7R+7yVPEjqEGpx+H3n35VI/F54BLykx5lOOCDL9hRjo768jE8V3M -uaC5Zvp3GfWpRNFd7+8Yw0rA9o/fNcJmhAprJM+g95HBOpe13tzKbxrIxWG9znGE -Y3bcwcXXyD15EnMnIZ8cBfug67hDUZ4D0twozQZkMjVRFMQkn0JjMp32kV56eCp/ -6oMpLQHzqbHo0PoWwoeea8uuLdgl9pDmRd6zyvfen3LNotrA+3L/G0HNkqQuKqLY -wyPoQVZXAgMBAAECggEANdZ0tpDRpsVMm+mRuo5jpIOxWOvn4AwOP1aEMlwg3s9a -KT3t0pwdKRCn6uOeKzl3W9ZqIpPLMiwHaHWgqEckhjgwjd37mPgvBWU2X8qKJAIq -gumLODNpWbJJtzq1aJr3FpyayTo6S6OHT6SCHAnYiaAwK3L/urvamkX+lD/Ue/V/ -ZTkqv6uxDnN90x1kyUmz1zl+jtQ2OnRlcGfQCu891caTKOHzhLcdX5ZIp6z4BVHQ -035ek9zSRpaE9n9wpz3OxWn7MlBu08Zs6f2mtZxLeU6Gbn5y7rPALi0MEeyh4awX -ohjgd4XAqQEEs5g9EMdIwPbkbdmI1cmcQOAmaWU00QKBgQD0hrvgszH2A12DapRj -X6sYrYutmVwSWmUJgC1gWMYWN+UGhXRKJ/c6dbdqgZOnZtwB2UHbo1q1mN9pbwU5 -Zu/4IaWyMBPIg8UiLhhZ8CCYGyKDaqZN+t5xJOQWphSB6uFZRhxNM0E6DOv6k63l -+GhMhwFA8nzuarb7Uf+IbK1ImwKBgQDr6aXUXFGqQ+ZOMIj5I/f5VOE9PkbcYBD1 -GWmU2h+1KrAXRnVxgxhwo4AaEPZuifZxA9TRh3N1MqOaU9iv4DUPrBqg0xXxtqeC -3lGs6d4xL2BfS7Kk1LoWgjU8hSky8ZN6sCTRW0pV0vtIBKRobErtC7XbPWk+nqAf -0WBgso0u9QKBgQCEUBt9XLleCzggkh01IGEue0mnZ+KAM9WULH1hMugMwbX1r2Tb -c4C9a1ESGodQ/8FwZqTSOjQtK0lIfcBv7RlQRLSqFIW/7D1RX2vhzqN0aspkHeNb -MrIGuxWIg9l46yWA7wUFaQSUasWN0zc3xxB4yFyPTib3w1q75wTERzoEnQKBgHLZ -F2sP2o36akdMZ5JqiVEvmku3YsXsWrUHvxfBLMiE1J8wJQKy4JYNctK9yUq9DWWt -iNDMkU/P7Ee4Y/gTPaG4lmoO+VLoKhqS4s48OHhXaSJbdse57DIDB6nD5e+wHa0P -zYzCVaj8gmpoICXZ+ov2NH1cIz1h+fAjfTj2E7d1AoGBAJ2FStCqn4LGFjkLatSf -0pc0clF5tBfihcxbIEWemG6oYUQNwbaKyySl+OI9chJYAaAdGDAHaSi5pZyZLyRA -vsVPAqA66sX3u8yepYsiM9jq6vF88lEguMRK8zYrpcSfHvIWT580WoGMY6++3w2Y -haeaEGL38Y5/VH72VaIlEQQe +MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCgF4OXW1j7wJKD +Kq7dKn4MU19yTzR01MkX1rsrC5kkFsihxNYd2pc8MdGB+VaJXaDwT7p/TL1FpGtK +ykgIp01nzceJNrfV6T79aslhvB/nt0BTKlCDDZTRogS6viJUAZGqRSWzbGcXt5GR +LpRGeXO6OpjVdQQqDwTMdbuHRTZ99VDfy1x8TwzWX4NA7xNUuoPfynWmmHKf80/F +kIgxWaRHDwUtKxn4ItVKNfMDAWfArdTMH7ZO4AYfIyM2WS82H587a0DilwR1Pcr2 +q7o6mFB807sdSrjiClUhWwM6A0KVsxnUvQAWkyYh9n01vnDYHrrYK74q1uMUJogc +45EXMhGfAgMBAAECggEAHC+XpQXZuFVS1lIlAF5zW9Mv+k20pB80moRdZro/h6mV +QFoKAq6SMvBofRQ7pqq746N959zIdCL7GutbXF6sU6rYxzFBk6FhzDdJZnI7Qc4z +PpE0JKa2/WOjpodEPvsZvNs4xIrA6d2RfPiw9Wl7tR2M/AQCrC8Bvse5sRq/+dP4 +U24eetvPJDTYLk3PFnZJPShAUEOcKUaL/73nIwCFbC8ez3ae9EIt4CO4ljHORp6h +g2zJFei7ie6VLHAZx4WUeGTVlhgF2bYjsjM1h254ZTIfNgqGs/DaOwzO2kpC5b+m +TE3Tuq1r0b7uMEnsCJb4gj39RYOqThZ9IG3I1oXKiQKBgQDMp67wfZm4jKeNfwr2 +gUxR7Btn0XqB6aMBofAgQiUuq9z8lRr8PTM1wPnw/ZKN6mYunIhXHGP+t8628hJx +FAy0fSy2sy9ucxipcDlyPBalSjtj1i1jqmZJtvmal7zfi0S/wgBn/J0X0lw7927Z +ai1VPVoHOeTouV4PhcJPHkqOuQKBgQDIQa+N4q4kCvmoMJSIHT9/vUV60uOO09QN +4WEtSUdrZVYnSYvO52f11bh1ZLRiZayEfov3vJ9LsLhnil5pNhEvxCZ3v+z5Fqgi +PRxY8+PnWleMC4QhCQOywpUbC5HqvqyEhGVVYt/CKbD0BKJoK/iVSkVUIhQuvh32 +W1x3wcG3FwKBgQCC9iL6fkVqVYe7Ajsvt1nxape2/dPZYnsPRmN1IR7OGOiXMYtN +MpScp1rKHlo0OnUdCsoshFxw2YqMg6fNeLkQnrGIUG3fzgNQGiKIuW78Yt5SavIs +vxQpw89CYCtbGbHqy+iaooqcfd7L+PCUbF+KFnKQATo8urI4WK4ZFxc68QKBgBZs +3Kbr6opYvEpsXkW72L+KR3yQnzEAYa/IPGSg3yGUsIgnwUNDQK4T59slktmt/xq7 +PRtaARCt0oitwxLPHi+WLKSeVoAyXFOxOjpv3WasBD/Hjl1QsBxVk/L6YbXC8njI +hryAHQSWPJ2m4zT9L5IwRgE867usSJis9HbouLOzAoGBAIZtLLPx8KYgjiVx8QPx +4uggZ7iblh1aI5ZO0XbsmWQfVDJ7HKpLFc9vd+nX2++Mv0vm3yv2WslMVliFvjXl +tgZNx10zn2usg+Cqy5728ldTXnXKA9q2KZOfhVPHv3sTao9bji5tywjnvt4ZLp+j +ngI3derKCSC10cXUiDEs3dXI -----END PRIVATE KEY----- diff --git a/test/configs/certs/rdns/client-f.pem b/test/configs/certs/rdns/client-f.pem index e774479bb9..b80de9ed59 100644 --- a/test/configs/certs/rdns/client-f.pem +++ b/test/configs/certs/rdns/client-f.pem @@ -1,20 +1,21 @@ -----BEGIN CERTIFICATE----- -MIIDOjCCAiKgAwIBAgIUBCTh+oC4QAQ5+H0e/fIvyfrkxTwwDQYJKoZIhvcNAQEL -BQAwEjEQMA4GA1UEAwwHTkFUUyBDQTAeFw0yMjA5MDcyMDI2MjFaFw0yNDA5MDYy -MDI2MjFaMGQxEzARBgoJkiaJk/IsZAEZFgNvcmcxFzAVBgoJkiaJk/IsZAEZFgdP -cGVuU1NMMSEwDAYDVQQKDAV1c2VyczARBgoJkiaJk/IsZAEZFgNERVYxETAPBgNV -BAMMCEpvaG4gRG9lMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA4Vbb -ffLby6ofWGu8tSdwLBE65p0IiJ1zQPw7ZUYga4SLcCBKj/ju6vBacBWZPbJqOjus -1IJd8YjONR64+fKKiPRv7e0fu8lTxI6hBqcfh959+VSPxeeAS8pMeZTjggy/YUY6 -O+vIxPFdzLmguWb6dxn1qUTRXe/vGMNKwPaP3zXCZoQKayTPoPeRwTqXtd7cym8a -yMVhvc5xhGN23MHF18g9eRJzJyGfHAX7oOu4Q1GeA9LcKM0GZDI1URTEJJ9CYzKd -9pFeengqf+qDKS0B86mx6ND6FsKHnmvLri3YJfaQ5kXes8r33p9yzaLawPty/xtB -zZKkLiqi2MMj6EFWVwIDAQABozYwNDAyBgNVHREEKzApgglsb2NhbGhvc3SCC2V4 -YW1wbGUuY29tgg93d3cuZXhhbXBsZS5jb20wDQYJKoZIhvcNAQELBQADggEBABZ2 -trCXmrjypDuTqNm10flqIp70yr3MeVQH5FFWP9HCzXQ9ienr9/RVapdAzGJqbVuT -XERyXleJisOHhezbAlc1lWHrhvaKp/Pc0zNZHFmgfz6W9U6CsxP82uXznsYdE+Dn -j+ieLBfW1Xs1wy1PGoih0AY+HUV5oXS5oNSIOZKlQCh7UTg1RZ7fudD29XGp+QG5 -zOQbyZu54A2L/CfPNArnL0xOT4u9nnDrbHoT5MaaB9aa6UugKikLxT+KZlgvjHwu -2RKPaSUDTq4l0AqsBwKCmNW2AH5vpCzOKXj/+TACUDB3Z5iUCWEpTbOqrqgihHv+ -JF9gD2O8SdNt9sAOVao= +MIIDfDCCAmSgAwIBAgIURF3HIP6jjAixTsMisMxARhqRfccwDQYJKoZIhvcNAQEL +BQAwEjEQMA4GA1UEAwwHTkFUUyBDQTAgFw0yNDA5MDYyMjMwMjNaGA8yMTI0MDgx +MzIyMzAyM1owZDETMBEGCgmSJomT8ixkARkWA29yZzEXMBUGCgmSJomT8ixkARkW +B09wZW5TU0wxITAMBgNVBAoMBXVzZXJzMBEGCgmSJomT8ixkARkWA0RFVjERMA8G +A1UEAwwISm9obiBEb2UwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCg +F4OXW1j7wJKDKq7dKn4MU19yTzR01MkX1rsrC5kkFsihxNYd2pc8MdGB+VaJXaDw +T7p/TL1FpGtKykgIp01nzceJNrfV6T79aslhvB/nt0BTKlCDDZTRogS6viJUAZGq +RSWzbGcXt5GRLpRGeXO6OpjVdQQqDwTMdbuHRTZ99VDfy1x8TwzWX4NA7xNUuoPf +ynWmmHKf80/FkIgxWaRHDwUtKxn4ItVKNfMDAWfArdTMH7ZO4AYfIyM2WS82H587 +a0DilwR1Pcr2q7o6mFB807sdSrjiClUhWwM6A0KVsxnUvQAWkyYh9n01vnDYHrrY +K74q1uMUJogc45EXMhGfAgMBAAGjdjB0MDIGA1UdEQQrMCmCCWxvY2FsaG9zdIIL +ZXhhbXBsZS5jb22CD3d3dy5leGFtcGxlLmNvbTAdBgNVHQ4EFgQU1Fzej0nnnMw9 +Aai0AC5g2XsdiDcwHwYDVR0jBBgwFoAUcx8l+IDw1vXQbyspw79qb06Cjq0wDQYJ +KoZIhvcNAQELBQADggEBAKqH6YEyYgW5CnhHNOlbvB7kCNrQN/nAITWJILkJRtch +hMhsODV49fj593Rp3vTJXJ+fRCwJeF5pCfHIyUaEC9FM8IERzK7yZUW3h6X/KfwW +vHdRabjsuNuXk92wvslZK82jjosDBvdLv0pnApVv5OPnSXDUr/kGFnXhe7OQgLAb +OE5o3jRHWGCiSa1CnXrY4fzjDNR/MRgk7N7nQ29cY5fC//3jtBlYlcY7smjH81OF +9kFgQK1Mf83cN3zFLkVejLpquVM1CX210Z0GV7hEg6zr0jS8v1YRnCQ9xp+Euhd+ +TIU2SuidadW4ww/yCWsBfBuoX8ijByvG8sYyQ/jXL3s= -----END CERTIFICATE----- diff --git a/test/configs/certs/rdns/server.key b/test/configs/certs/rdns/server.key index 166e75b97e..c32374ef85 100644 --- a/test/configs/certs/rdns/server.key +++ b/test/configs/certs/rdns/server.key @@ -1,28 +1,28 @@ -----BEGIN PRIVATE KEY----- -MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDAcvznkGd1z31j -nAI4+11fmZuY3RYCCdfBdvKelxik1vhQgLazm/eghtkQOt41tTN6RNkfbM8nGAHE -JrOS0hpMPZhODVukyUbb7K/RNFNc+TWf4AktDu91KytDvi5ag3oJcvUC4HMla2JO -BaCpETejOpApV+IIvI65l3XErRQ0b3XUsLDaQ8+NYOTfU04pdmH/c0lXaL7F3NAv -IH2fEeAe/nSNACGJg/7TGsRyzK92rZHwC4F8RSxWd02Nyje14iLZ1Md/+ndT0ito -u5zZHs2XdkkJQ/8E5+IVbrcB+MwFjyOE8bPZGnFpfrvzXEuojoEbgrfA+7h7W0l2 -RInxonA1AgMBAAECggEADtaO01fZ8kZuN4jmzvfqih1w1sdtE/koTn1aVYn213bP -rH1QGOcUn6bmA49WZLO05V97kiW0jyIVuMb3H4HdjzVMkfALudffA8PrBmlPaCK6 -1LnUW0oEgncyncWDE22BskrPw0oE9sShzrw2V/LA5G/2f4mMHvpS0tJvvRtPLH+t -N8gr/vh9b/h9UrTZGWISKgy6J295jKG39pXVTlj1b37oRW1elMHKBWac+u6kj+wQ -oA52VArMLhObGkGQrmypbqIxAM+97aieIw7c3UOIMHyO8LuyYrkrOFUQAvJ6NkEl -LVpHl8bO8kJHsh7Y1EqE/Y8DjwCEL2HR/MtyRhsKfQKBgQDupn3v1jDw72c4EPTj -VL7xVy4XAbBK0Z5WUvTmItQ5qMSLGpKgbzW5E+kgWzMlVHs0psFsUS7zNTc2ueuC -K8pQhQSc7IymXEkzjAbfQjQi+TSjgGoaO2WV03nVkUKzfUsTRMdJu+tljFKZGpFD -/+uMooslqjfjYDU8f/+lYiNq7wKBgQDOcKX5CryR49feMU4QIesWrHsXeajMge9P -cJKLXiIzr+n6QAlK4xB5kMEmXqX6RdTqBZlmwsPva/A8OVBmZ4YFVX2nnKmcnJ40 -03xBW4UDeugNh+gstRBPHrtCaKGRu1Do9iyydTc3lSs5+sKsTnBUEdEphQ3xYZHk -tFWopiBnGwKBgAz5ekFOyMxgh6ERsu6lDdh7H+NaUSZQLSaOTggw/o6/8SeK40vb -n/UW8wayTp6J8ETViBCGfWH1k7Hi+73Q+afVA4IwjhkBTW2DAGCk7ca0+7qj4aDZ -d9VkcOw+gHzXo/xBMgB9OfgEX/0454rl3/1+XMhIb89pzJskblakdj57AoGBAKc1 -0QmOK7zTWrcLIpqojn1YCX+zOAkluYuTt+8QuQ06kH71PVGd52s/12LXyQKVa2Z+ -UIlOelvEBtsQ5VF8yq4pV9TabPuAVBifsAZUNcHi3HCRQ3pq0iHz12Nr0mpy2Y9I -Tl3h2W648UFOHj5obk15/PvvXKLGD+C6PKOUo6w/AoGBANXocnB2fLUZvK6XuQ7A -qwJQX0nxdFHGEPUy8Nh2/uCy5sBk1mdpMKMOnQ1n3wk4NEfUM1VXLfCseqlhOECq -5a6oxlF6OE3XZsLq4Ix5ntgm8Foj8ccnKJV0Lt9bjgJDK9us8XqsqYChR9d6BBAN -wbzXOgpAZ3k5/yKS8iafUH2k +MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCjc0LulDTiYpXX +tTTXW8ubZueU3abq16rixbIbpQ+hZlpGhPOMDQbBEJdFuurt6GiwUJYvPonsuLxM +VhwDBGwKAs8Sw0vjwIHoPNBo8oKa7lW6Be2vv1+VBiDOd8ua7xnrLBmpKgADP40a +J+VAgSSCAVBA19tG05CJbxGnGHBgXqNwMamR+DhQYp1JV8JqivGA4UqOAchHOyp9 +ucFItKJ6EeB/qq1O53KnEcB5WqHYGy06/tJPQ/jsdQxakSaVMrKvrhTY4XkSMPAA +sOcrX/BFpWkloNthICYP2ROzV2HYTDfQgGt1SU4wdNseOsRfs0TQRKMa29gx7iQI +pH3D2i/FAgMBAAECggEAArqksjOWy3Xebx7XLkZZ2LMn6DgoNpEZyRYIcoY3w9ff +54AGSf8YrwYOJIupqwW/o7wAufK3HlT6TeL9Lj63aBZiazuIC5o2ARDs4Oe1rw0O +MOAy9wWAvM4Ao7nj1CcsXV0b45NwMx2vRzHF1eUiHSqU8rQ39M+JAQZx+sKBc9Zx +2oiL2Dy2q6YBqgJA24dDk2S2bez32ZWBdyJ+/kMzanhsHZb4a8StuxMjX201vhmG +QzV9PR+oi2dn9Kee/GX4yZUVDZ9A1jOdusk0+SnAPJDMi2JEp5kj898GXW22PZCw +mQ8iEqJCmsB5zWUiYiF0IkmTeSkukZoX3YaTts9jYQKBgQDRBnGrFimcM9QJVbeR +ObGix2TxmgKm8qkLuUb4LX/AgLHCNAy5SdodMOFHdV+zZlrqwY3d54yiFwix5ujD +AaJcAhOKQGX0aTEz3Vd4XIj9Y/uMwhU9XG5zTbbT0QlVWLDy93KJYeVa9ateJsg5 +DBcF025ApLQv/Z6bT2R7VIjdYQKBgQDILtFktkfvQS/uMcJDX35Vw8VDsJWc2Aas +oBQBfHwFM7mzfoofmHnUFh/901uSXvj3YVgNHnSQx7+sJQhViO3RFHSNHwyTs7aV +RErs/vseFpYf9SorASygkOR9bH4z+KIw2GpSMUIWq5c8E1xe7lkZUuHJhQht8Vzv +dVwHBfUo5QKBgQDHwObD30wokIcj3Jyu1nnh27emA85hCSlvoMInziN2LgayVteK +Av/EQcAocAzi/wAHtK0E0ZFeHbEbglYSde9ZCkruJhjI9/YjYHWE+rmXngL5Q0jU ++Q48dpov1maa/0UrDDqS+9EZmgkI0vspOVqPIL0OXdgsvKzkM30NN34MQQKBgEzn +N4giQsZWW6x9Ly0kzWrzV6AmgYOMthuxL55WjWqOMYQUU8nJkNv6V/XyMZasp6aZ +nfMERTGtmyPt4iLCBOKyogfo6rL/cmArqUEcv6oScT/7tmRpAhT5NN4+RMmAdgaf +zVCgHcyJxQLOSUkq9c21uonpcpCSDersQhtsnX9FAoGBAMLm40fsn5hqeOSHfF7W +ZEX0eKSBPuCCWTtUi5c7pPmyj0B8+9o3wiP6YHcs91ysfAWgnJqBlZkPxkwC5zvT +AlS1GNsCCQzZT8c60QiOESTMWa+398AGtFRYVNjbamGcQOW3lprfeXiIQCAyQ2d1 +GNZICja01bMZsLidFoyUIH95 -----END PRIVATE KEY----- diff --git a/test/configs/certs/rdns/server.pem b/test/configs/certs/rdns/server.pem index 90e8d71fdf..f0f4d722a5 100644 --- a/test/configs/certs/rdns/server.pem +++ b/test/configs/certs/rdns/server.pem @@ -1,18 +1,19 @@ -----BEGIN CERTIFICATE----- -MIIC6jCCAdKgAwIBAgIUbM5eMdzKfamh0SDEqztq73kUDmYwDQYJKoZIhvcNAQEL -BQAwEjEQMA4GA1UEAwwHTkFUUyBDQTAeFw0yMjA5MDcyMDAzMjJaFw0yNDA5MDYy -MDAzMjJaMBQxEjAQBgNVBAMMCWxvY2FsaG9zdDCCASIwDQYJKoZIhvcNAQEBBQAD -ggEPADCCAQoCggEBAMBy/OeQZ3XPfWOcAjj7XV+Zm5jdFgIJ18F28p6XGKTW+FCA -trOb96CG2RA63jW1M3pE2R9szycYAcQms5LSGkw9mE4NW6TJRtvsr9E0U1z5NZ/g -CS0O73UrK0O+LlqDegly9QLgcyVrYk4FoKkRN6M6kClX4gi8jrmXdcStFDRvddSw -sNpDz41g5N9TTil2Yf9zSVdovsXc0C8gfZ8R4B7+dI0AIYmD/tMaxHLMr3atkfAL -gXxFLFZ3TY3KN7XiItnUx3/6d1PSK2i7nNkezZd2SQlD/wTn4hVutwH4zAWPI4Tx -s9kacWl+u/NcS6iOgRuCt8D7uHtbSXZEifGicDUCAwEAAaM2MDQwMgYDVR0RBCsw -KYIJbG9jYWxob3N0ggtleGFtcGxlLmNvbYIPd3d3LmV4YW1wbGUuY29tMA0GCSqG -SIb3DQEBCwUAA4IBAQBani6Opa+XsyCKgpae38+YMdXCBb3zL2ZGexxqMFJ6JviW -1kMz4+hOcCnoMmIthVvKA0nqVbq0YozbZUFfR5HZ29wGHjnWNbHUgq3um08G9uch -81s04doN3XBvxNo9tUOQipnv1w4KVsXQrTi2o0zAoDvxokh5AKjQxR2R5r6MmSW+ -WdbNOxT5TEyg4j+mphfLRj/RkW7uc3vT7Pq/3KNOnSQ2kaDgelLgu5ZnDEJ+KIz5 -xUh+CD09aX6GeljgcIotk9KSKerYEZuBL6dcEeomPZzd+amGl+GledDFR73rMWN7 -aHQEsQgEtT8FW2eoTlEQ+/c8SQ7Tf26rMKR45qIr +MIIDLDCCAhSgAwIBAgIURF3HIP6jjAixTsMisMxARhqRfcEwDQYJKoZIhvcNAQEL +BQAwEjEQMA4GA1UEAwwHTkFUUyBDQTAgFw0yNDA5MDYyMjMwMjNaGA8yMTI0MDgx +MzIyMzAyM1owFDESMBAGA1UEAwwJbG9jYWxob3N0MIIBIjANBgkqhkiG9w0BAQEF +AAOCAQ8AMIIBCgKCAQEAo3NC7pQ04mKV17U011vLm2bnlN2m6teq4sWyG6UPoWZa +RoTzjA0GwRCXRbrq7ehosFCWLz6J7Li8TFYcAwRsCgLPEsNL48CB6DzQaPKCmu5V +ugXtr79flQYgznfLmu8Z6ywZqSoAAz+NGiflQIEkggFQQNfbRtOQiW8RpxhwYF6j +cDGpkfg4UGKdSVfCaorxgOFKjgHIRzsqfbnBSLSiehHgf6qtTudypxHAeVqh2Bst +Ov7ST0P47HUMWpEmlTKyr64U2OF5EjDwALDnK1/wRaVpJaDbYSAmD9kTs1dh2Ew3 +0IBrdUlOMHTbHjrEX7NE0ESjGtvYMe4kCKR9w9ovxQIDAQABo3YwdDAyBgNVHREE +KzApgglsb2NhbGhvc3SCC2V4YW1wbGUuY29tgg93d3cuZXhhbXBsZS5jb20wHQYD +VR0OBBYEFBTXnZytLW93IszwKUGgXXh7OdNtMB8GA1UdIwQYMBaAFHMfJfiA8Nb1 +0G8rKcO/am9Ogo6tMA0GCSqGSIb3DQEBCwUAA4IBAQDCrwa/UTnBOoJ/X2FIfaWP +g0llr0OSQx3l2RweWte6O90VB9AWTgstYRVErmYyXV70lYNp+HOPpxak1DEGr+P8 +4REsMjX+odz9+UGOq/n5N+0VAfLTsQ9CG5EnHsfzwamgL/Ax3czrzgvmP4lz0tvp +07le9YUWkuG9UsUhN4/qe65LVweg8AfhihiijlcQe3WnrB7WvyyOZO81lBnLIIar +qq62NSNxPWNa/TGX/og+E5HwTPcMNeMOsok5D5TQtx1zNX+2Zj7i2Py3ScTCCY/G +4U1nO4k+APE/3BKuvnrz8ZJ1UglT0lrVEkVqzW7TNCJpDz37A9QIQVLpw8oOr+Yc -----END CERTIFICATE----- diff --git a/test/configs/certs/svid/ca.key b/test/configs/certs/svid/ca.key index 33b50b6b85..1e66d40491 100644 --- a/test/configs/certs/svid/ca.key +++ b/test/configs/certs/svid/ca.key @@ -1,27 +1,28 @@ ------BEGIN RSA PRIVATE KEY----- -MIIEowIBAAKCAQEA80Tp5sAViZpNLM1O+Jj+kJ1swKzaAXzxWLHRuusP1B4GNvyV -QaY3Qx1cSmNA9JN/4Hxw7Wou2CgfpKIiCSkPSQacN0yPDFaTzNk3UkL9/bjstRKC -8UYoKanDc8mPOUqDaY7aAoqaXWt3TTmctedghKMrISL/+MDPC6faweF7YSjAB6sx -Sp4qfIts/jEAy6ioy2M5vTxuirmjhSfI3HXeq0uZmV3f5MIv8iZCF/z4MJuJ2MqF -BjpnCr1+NBiqWJSAOT857Td0cYq7WFTNpXr7M2ygmt0d9iKGcck8eJPJIevIyQ34 -9ldN3cQLqQ4/xvDT7dcv9V6GGe6SX5y/uLDYbwIDAQABAoIBABTm4+4GrRMQpfbm -gRWNF7pXPGPltimQkbAcPzf/QHHqToBk/XIRlQf4OtjNZGRfVAp2xsEvcWzzLZzY -rXH6DC0rGzsJIfVebv6X30/7H5WwUO5R89xFOegyhO+q7tpuU5I7SvIS9KZ4OFzz -SUq74agj2O3U8wdtkZyfxIUKGa7ERbE7+d2BxwTmt/KTMWkhiaDberVDfBVm2RnQ -5beabdx862linT4ntFZHvnu6/aOv9PEdU7UQZph1e/L7pc0PURaX0Rn0MUlcXXDN -Nk/b5wGn9p5rFRWfgZtDxAzowsT2h+UVMXugn4APoDvPWvqybbLub8b3TmI6KD4Y -PzpnegkCgYEA+atJ9FmK7q9n6/McT1Ac/nvCyanRwyF1TiC3hPzQloODe8nBhOlE -H2s8QEUPTQJg/YxQWhbKm/su3F4ZiNRWC+k0lOD+3Rz0SCBnucUEfD1tX3muJJyw -rEsSJi5RDhalC7xePv63jML1rPNr/pAN//xxVdMFeNwjRbJtFoG8K40CgYEA+XAU -icBmojKfiHC6lkf+SZgW15sdI9jKMrg56b5zhk56+JAwca3A9pGMdK+4AYdakhG6 -L+sc4oaewLqxIHv247M+zeIzQtXx1sYmIMjy7ujzYEy0be3O0BGmKSBaS33IcyUY -iZprvUE3YA22rVJ2m98GWS8S129S5KWGtQ0B1usCgYASdw+mKcUzt/dYpQdP+l3a -mG6kmZGw+9WALL1F8ai/qQRdcGOGn/Xw2O6A1lq2WFmyBuGeeBcOCDrEA5Wh4App -IRtJc4aF9fE/MF5bh+23/pcLO6WcgZYzd+3kswI9p4EXaBwUTqRmnbirzOkMz7yp -VRNQxKWf9bAKJJMa2gd/tQKBgQCfyTp+269ja8ZiYsREDK5KepD3YLgUBIXSY81F -fOkIOjHwFH3T9JhN2wL8pKvc3tYYCB8bHyOLwOzlTTK2OnL3fhVXUfXAdMjM6nX2 -PoPQo410PO7AFLyM8SFd6wmsnlDP4g2L6E3oGGTetSo2cULlqsKoUs1hEEErkxVt -2X06LQKBgD99K1jrCU15CBWiIqY74TPkyBMSkxRhNXgfdO0J1a+Na26B1PTSkBK3 -DwL3X9TFDVcHFUdRnharxOYLQ30bi9pppOWl10KfMmAvtFl9xBXUG5Je/r0ZYJGP -YJkQz3Bp77RSotGmlMDtkaTQsPd3EFyaz/+4vVre4o5Uxb24lg2r ------END RSA PRIVATE KEY----- +-----BEGIN PRIVATE KEY----- +MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDXYllrRiGR1WPO +rT07fN7bY5q8Pnsb1zaO13ZlTdQpiNsEa9AkOL7NaAZFZJ9+KdhQYQgbAUb5Cvyw +UIrydTvDrqzghQLaHn9VEHx7xJWJRaCYSqB7MBZCsc7ov/4ntIQO4H/aYhBdcXzj +ELpqeMSSLpnH9+9KmZU4ArxU0dqx+2YzUoCDXszsD8541797ksrxrZnLkuNxDmtZ +ULn55pY/MT7Tq0gkUA+ReDpHeElQuf9L40ODdueSpteR4mDNPQmLoTE5qwTsyhjF +Bght+121Chu3tRwprJqxEjwe/YB6rAFVnlgWwLumfYer/jI8UNoSsiVlj8ToMR11 +kIVF6NGTAgMBAAECggEAVJJoJSCxDsfY/G7207R493FZcWAhS/HKGPWOpkGUtMhp +o4dH/+kONq6Jg9b6b3oz13/6RExQl3qSdRLzNDgHQxOEC1b/IzGFcxvZnWm4A+JE +qHfpIuXjX8XcxnSY8fNGRWcunMwTu/VTgf9wC12nZfUJakU2/zZmKsucMrwCIQ8q +rYBoHlVVs/R+3Hj6FYj5yFeoCsWyPswFd07llu6/h8ADY+P1xnOeilJ8pdNR6vaQ +wZQhBc0m414XRp2OzpKAX0+7sATSUhhGnU5VdlCcP6whHKmva2U3RusIN1Qy7UIA +35sNxMsSzOvozwZXbWMpWaUU69uLtGjeX6qhh+bk9QKBgQD6XyViXijKHN56xFx9 +4inTPlqOrgtuZDm+9pQ/TFaZJfK4GoG/8QyUOXmLAnxbbTAAKWXc/zHXhVr71wsW +4pgsUxypWfND9yQ7dYfJCR7PhkYqdRm3WG+JOss9aL+FULdqjD/4tw4Y5EHc2vpO +plQ0p0/xJtLAlg0aqjAonjDUJwKBgQDcOdrrklov3IvKw7LgKYmvDRjLGEyMm3qs +0fPgWDG7BzZ8nfDQ7o2Pglf/ypuLYTQyZV4DXAXdiQGjkM/SzStsSV0hmEFfaLtX +JPSbk6gjW1+9+sxq1xJfxvu9tlUeLoRwA0Ck0rwGn3y3OjcQCCVL+5jkqmmERihM ++3IY8+/etQKBgG4yZHToNpHGpRFpzb/GRFxqrFbyOavLxzLKurMleVQMxMjNOeBu +SvgOV/WcEXn4E9FuZxwe4iQW2NXRb1sSPqH7rrjHE3ANnc/hyfLs5be3RLi5M6lj +7it7SirsKKeXwDLQKfPhNf40sNxxMQxe3t8R6Pid+tKy+G+NCodGIP2vAoGBALWE +sl8tGE0O2eJc/5koY6X3g5ITCzVyCeFchElMKGFiBpUckZuEpQW+h838L8zoZ9+K +Eb1vIh6BiOpKuCGmnr34klzYZDnB13hyq3N4d0P9UqMCj28YqrprBqBOI0ZnTR4O +cD/qurQyzNcxkqUSMbu5O0Ju+93c/ebF8juDBRlpAoGAM14TPQSUz4oiMVB5VWAj +75OK2rFQLC+mMx2T7u8UqpHVb+A6lUZcj0aN6TgRQxQo63bRXaEc/13BTMKmmqze +rM7bpj4+b08Fr0yhw7fjO2b/q+zn8Gagk6UWIptpY/8WC4OSgaSjMC6ZErPWqRJs +cJXNOa3YaoQcl8SfLW45RNg= +-----END PRIVATE KEY----- diff --git a/test/configs/certs/svid/ca.pem b/test/configs/certs/svid/ca.pem index d7fe3b88e5..a8fdfc4f89 100644 --- a/test/configs/certs/svid/ca.pem +++ b/test/configs/certs/svid/ca.pem @@ -1,19 +1,19 @@ -----BEGIN CERTIFICATE----- -MIIDBTCCAe2gAwIBAgIUWx6o9zNtOfrdrp32zgDDiP6CmOIwDQYJKoZIhvcNAQEL -BQAwEjEQMA4GA1UEAwwHTkFUUyBDQTAeFw0yMjA5MDcyMDAzMjJaFw0yNDA5MDYy -MDAzMjJaMBIxEDAOBgNVBAMMB05BVFMgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IB -DwAwggEKAoIBAQDzROnmwBWJmk0szU74mP6QnWzArNoBfPFYsdG66w/UHgY2/JVB -pjdDHVxKY0D0k3/gfHDtai7YKB+koiIJKQ9JBpw3TI8MVpPM2TdSQv39uOy1EoLx -RigpqcNzyY85SoNpjtoCippda3dNOZy152CEoyshIv/4wM8Lp9rB4XthKMAHqzFK -nip8i2z+MQDLqKjLYzm9PG6KuaOFJ8jcdd6rS5mZXd/kwi/yJkIX/Pgwm4nYyoUG -OmcKvX40GKpYlIA5PzntN3RxirtYVM2levszbKCa3R32IoZxyTx4k8kh68jJDfj2 -V03dxAupDj/G8NPt1y/1XoYZ7pJfnL+4sNhvAgMBAAGjUzBRMB0GA1UdDgQWBBSb -k8cNn+GMdIe4iDRNAA1+pzJKdTAfBgNVHSMEGDAWgBSbk8cNn+GMdIe4iDRNAA1+ -pzJKdTAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3DQEBCwUAA4IBAQBz9+rdkh3i -+8MobGVTlsvqgaiAZnW+St3/xrDLngbi3gLRH8sFleA6HmVln7J54bJSYKTnmEjC -4+2dJuXzan70u/BK7genpzCcHM8z8BS7okoaLT/emuAjBgMvAhKIlVjKvXag5a2b -twzDXX5ilEJxRELV1S/tIUzf7+9IUL/Q1OUXYeGqxd7R+fX4pe4jzA8waNWlpSXU -BsUR3t3zecERQD9SD5LVb/0S4tvjdDzUHhO8CDG4PzWaIwN/EDsjheIcsonhxAI8 -RYWDH9trivJbwDdaCF+dxfWbh/Shy6YGYV4YnpDAu/fFr0cRNW/kwJtpDgjUIjdK -fCLYaHLga6sL +MIIDBzCCAe+gAwIBAgIUHba56kOIMIRpaKPovfEccmejyJcwDQYJKoZIhvcNAQEL +BQAwEjEQMA4GA1UEAwwHTkFUUyBDQTAgFw0yNDA5MDYyMjMwMzZaGA8yMTI0MDgx +MzIyMzAzNlowEjEQMA4GA1UEAwwHTkFUUyBDQTCCASIwDQYJKoZIhvcNAQEBBQAD +ggEPADCCAQoCggEBANdiWWtGIZHVY86tPTt83ttjmrw+exvXNo7XdmVN1CmI2wRr +0CQ4vs1oBkVkn34p2FBhCBsBRvkK/LBQivJ1O8OurOCFAtoef1UQfHvElYlFoJhK +oHswFkKxzui//ie0hA7gf9piEF1xfOMQump4xJIumcf370qZlTgCvFTR2rH7ZjNS +gINezOwPznjXv3uSyvGtmcuS43EOa1lQufnmlj8xPtOrSCRQD5F4Okd4SVC5/0vj +Q4N255Km15HiYM09CYuhMTmrBOzKGMUGCG37XbUKG7e1HCmsmrESPB79gHqsAVWe +WBbAu6Z9h6v+MjxQ2hKyJWWPxOgxHXWQhUXo0ZMCAwEAAaNTMFEwHQYDVR0OBBYE +FCcUWYVGF5cPrQMR/VNkapjuXMRbMB8GA1UdIwQYMBaAFCcUWYVGF5cPrQMR/VNk +apjuXMRbMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQELBQADggEBALdP3pUX +SkBo3xJ1m7KskL6Xtic9eDxu9aJKYUH4qw16Aoyj+tZm5R1UvyaEsHMG+hFOZRRp +tArbOknL4RZG7Tx/ATTiSQl6ozmkZ8GRpKY6VsN5c6Y1e9sbdXeGgfitWMUkQQhD +Ftqps2TM6IfJBdj4BhVGAjG45tUhOTfMjZliaNZexVyR6XjuhDHcDDpcdaFgDfDA +uAYDDbfhO7MIKxplzrPcI7e9zDdb9mgB8UExNltxrH9w3J1cG4VpKxFtXYs5FO4d +swXWTr2cY4sTT/bhVJET+YnHyyZgg+Ear4n7eujA9klUHEMwPy/QDCn8u/091yew +NnOmSiP2A+dWQB4= -----END CERTIFICATE----- diff --git a/test/configs/certs/svid/client-a.key b/test/configs/certs/svid/client-a.key index c6198b5e81..d86b6e7935 100644 --- a/test/configs/certs/svid/client-a.key +++ b/test/configs/certs/svid/client-a.key @@ -1,28 +1,28 @@ -----BEGIN PRIVATE KEY----- -MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDaLYIRC2+s80g3 -rDxnoH/u8NWigZyTnC/eDec2ro+iat+5W8uFIrvOdiFK8FDMs8nqrBVPHGSj3o/n -HtKM0Tm/RlXAoEzgOwoNUlGpfU8gh62npwPKWvVU5bjLlwJfV1bqEfuL2UkkqeS9 -3FV0qIDkan1xs/maQ2LIoL4d7OzfjKvnNhAwdRBWuPaOzfKDg1+ME4UMZCqSEFI3 -d/gnvoBLYxsfj66iCSS91x2eUn5/wuF3yd1RBB8I7JLizoP7FPKqNdtvht2rKAhS -RA0P61oNn5JeDDW+Xtfvw2DusJv7WXvJRTUjJ5INwKwAiyekrx73TvkQTFD6+zZ/ -QqCOPCQJAgMBAAECggEBALishojI5lk9f+Zn6qVIbKGixyILla44KShLGmflr/yp -e/+YnJdvxApJYXreGXZ7xDDYQh05ilJOw/280DmTq86kyVcIGKpALw0Bnc/aGo0N -a0cajpHNFhYrcJUbmE19TztHx2Ujoc7f45d1lfvt2VP+c3o3/dG+sjHiJaqM7h91 -kK//Nu2u5Ox3jzHCRYfhv6L0Q1jJxUXiyWkT+eOkIGu5IMQlcoTp/qeKoxKeSH4F -YAu6fDiCAakRsINieSsS6Rh7EHQkR5ijgc72/F7ZsJfStU1QC40+/Tkp89M4l6uN -3kMLAxutAgCM0Oa9WwnR1R58UwBp/HIr56tLyVTZeNUCgYEA/j9nq3gBnFK6zbGq -mbq1ecuoiC0UB+2keCpr4zrUg3Q/j8SkXiuyFYa7iZ2BvGQKVXXhZc/D2/kUEQZh -YfITzy5o5PXZJYl8bZ43jNa+Mvm4fC+2avkVa/f3s9TaD6Zoe/QRKZkxxnbLxQFB -TX5XXnhVPcsqbX22HqiaUcH95xcCgYEA2652F9U0/QBZdibotrW605Rm4RFLx1M2 -n2Ri3nCIx666hsHqzucwfrxF0KoQUER/ld1DfsAQE9QXR85IJZ0gjkdhNfYBC90n -LvsrWrEDxOh655Iial1sHTSZpFYl0W3se3S/NJW7azcMAcBo7M1ecZqBdiLVtjng -pGpV3XaVQd8CgYAWtNjwYmZabLUMO8rNsfQVLZAeoVABqUKgDMHX6GAkYVRv5ZL8 -ahCchYzoLG3ywkh9+2om6phGZAdbweMemT0VqsJpeF9tT8sSCyhQ5rjT2qOUS7qR -8S7tlpbDs8XJ0gXQ1CpYObtNSzzFmmgXoKny4PJT83oVjz2dnVcy6A1h/wKBgDkr -MqJLIsoAcEeWIpOBwYfUI93IYX8SwbFDL5ORl5bXesUc691CPtWMa2K9DxfEa6t1 -dF4k30o5tIFERnQ7asB8BOlFBsqul8bbKFImpMN2eJ2Q4xHpE/yZtq4UmSziPVt3 -a1bk7GwfXCmMiAGwBDbuLWiv8gvFDhfbcFL8zCTjAoGAPpPA0rh2kI2Oly5C/8Xa -vAdVQcrX+F4mINdt5KTJGi5UmLMoFoBgB6KKse/LTjsJCaULQ8UiknDfoE/OxRNK -VDiBeYNrlWZUDBwyjtPzCL+wumvk+w+kmHKI4X9492frsoqHmudzYuJI/JLxxfNB -+Xs/tFBP/RW4N1VjNBlKYXg= +MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCUuqRV+zUywU/g +8Q5z6i+mJxzHCXjM1XPKu3gmWHtTTfRbQtvGdFg5mWHL8rgvEkeYkK+yn6NmGFPP +z8vJDLyVzz70YQpi1Qv2Awe0bHTgwlCXAKUlHfEapDh3068hEonz2Fp8n652ArNd +oaKHJCUZtKIfm10cs+nX+cuiv+trfJUVYxPyrQhu7lhWhNRwDWedI3pc7382mwze +SwFft0Mi1AyK7JhVMRM6ld91MXuJlLNfHKEejrumkt6dIP3o7cJJGxW4IFjDs4gh +IK9cd6JMeYQXs9Bc03hKazCKCWITrPPiz0BD7beiqFUNcPgOlzqveBnqsXyRLEjE +iQ9a9QwDAgMBAAECggEAEC8994FOU7HyRacrDHVyg/aDoivSB8WT7n7MtKzc7BQd +QC/GshIyZj+JAzmWzhXY0Vhaq5RwTTQz1/cOf61cJEKY4N0NKp4byW9LpQLxtmJO +2hp0M4AjnuOPUDLVPu3BMgDcL+2XKDkOWGULcQCqQjbZjEOgM/cRaQhCHvlwM+er +JqZ0CN6zPrcQTVlwEZLiL+aQ3igZwXaEPBq3VmuEW6rjpq7n7AE19GCmtwzo9PXW +BxZFKMMDxsiiqTY/UyM0Sfci+oGYmDMwVMFh5wDdsyAv6ulF8g0U8YTV4w8uBj0I +BRsSS8P6nwUIWGS9pz/1mgnsESPQtj9cs2dDUp5P0QKBgQDRCdVvlObEeka/rlIM +to9J2iThHPecXHHfD5S5AxC6/fU+n/X2k3Q6GzlYIkFdYQzic8oTtQaODtib9eFL +XHDCNyj4x3Gb7UPBl/f9uqIseUhpAJk6GRiUBgQlCJGp4btMVNx1bhoU+nWgysEo +eGvC/B8WB+04MLGURn1k3TTnawKBgQC2JE/dLa7bYxKH1K7h5HxwDjrdYQGFfWIb +9/uFyZa+1NAWYj0TD3vy/pox7PI/VMMa6oWl2C6Mv7aSLlFTwcZz3YKPv8iB7WHR +F12/s5xcKNID37J4Fo9EFq2751OqKyhW0aU65a7W/mjJY1loLo0fZVmuc1ZGPcDG +v39nwJ1LyQKBgQCY8Ub2Qs2tB4HoENT7dD7WXAMLqbQI9SJjf/TigLmm9tSOo17E +sBIjyXNlZnrIpY9VyD4buSE4ougdBAN4rgPaNZ2Gl/Ypjak7ZcMOI5UwUPSHzuZN +Obtf4h76MZDR6NSu/o/mY0419yJFKNO2lpTRrsHXzqjjqczjncd1GtvwTQKBgCVV +Ug1axMFxECZJQMNKavso34Xq0T4EUiy7apGknUJmKnS8FBqpDNXku8RJ9elnPUpy +EYzJv9jXnttdpQvO5xduqsk+HSIMfwU1jeCyNvVo5IsoudMFhL4HC/s80hhKGk2Z +UQ2+cFTe9ql4tKW3DPQHeRdZyrBBDhduvvWMNHGJAoGAD2x8zNEhBqOuBn5prtsC +WPsjXRIjhXIlQbWwda30an74Bw5Z6OWgZr8nUjBtHn7RkeS8PqTE/UzMTLqD1+TD +PvnA8GZ2WWdxhdqy04qkYS5SnkSSLeU0hUYZkLrjZJv5QdTnhBBVG/kDDI7TO8NA +gKMQVjTCSStdZm02D6EqEfw= -----END PRIVATE KEY----- diff --git a/test/configs/certs/svid/client-a.pem b/test/configs/certs/svid/client-a.pem index a264ad7dcf..73fa7ad8e9 100644 --- a/test/configs/certs/svid/client-a.pem +++ b/test/configs/certs/svid/client-a.pem @@ -1,22 +1,23 @@ -----BEGIN CERTIFICATE----- -MIIDkDCCAnigAwIBAgIUZ1mDw2Jbv4ZL87JpwO96ifyd+/AwDQYJKoZIhvcNAQEL -BQAwEjEQMA4GA1UEAwwHTkFUUyBDQTAeFw0yMjA5MDcyMDAzMjJaFw0yNDA5MDYy -MDAzMjJaMIGOMQswCQYDVQQGEwJVUzELMAkGA1UECAwCQ0ExFDASBgNVBAcMC0xv -cyBBbmdlbGVzMQ0wCwYDVQQKDAROQVRTMQ0wCwYDVQQLDAROQVRTMRIwEAYDVQQD -DAlsb2NhbGhvc3QxFDASBgoJkiaJk/IsZAEZFgRmb28xMRQwEgYKCZImiZPyLGQB -GRYEZm9vMjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANotghELb6zz -SDesPGegf+7w1aKBnJOcL94N5zauj6Jq37lby4Uiu852IUrwUMyzyeqsFU8cZKPe -j+ce0ozROb9GVcCgTOA7Cg1SUal9TyCHraenA8pa9VTluMuXAl9XVuoR+4vZSSSp -5L3cVXSogORqfXGz+ZpDYsigvh3s7N+Mq+c2EDB1EFa49o7N8oODX4wThQxkKpIQ -Ujd3+Ce+gEtjGx+PrqIJJL3XHZ5Sfn/C4XfJ3VEEHwjskuLOg/sU8qo122+G3aso -CFJEDQ/rWg2fkl4MNb5e1+/DYO6wm/tZe8lFNSMnkg3ArACLJ6SvHvdO+RBMUPr7 -Nn9CoI48JAkCAwEAAaNhMF8wXQYDVR0RBFYwVIIJbG9jYWxob3N0ggtleGFtcGxl -LmNvbYIPd3d3LmV4YW1wbGUuY29thilzcGlmZmU6Ly9sb2NhbGhvc3QvbXktbmF0 -cy1zZXJ2aWNlL3VzZXItYTANBgkqhkiG9w0BAQsFAAOCAQEAdjJ400sXvpfYGAdX -Sp79sWp6AEHIsDgyXnviS9HsGysRfGEMNFnYHg+/YTj7y8bRegvkNHKHZK41gHzp -QuaAnk7py9lJkwKvSJfIrchMhnnJRD9cb4VmwMYCt/vNCF20SeGR8wjiuZOVu4OM -kTEjcO7g3EejDQKXE/PlX0L7kT5gD6ddlCFdkhKsKfvg9XHdA/jasTsduUQjjg/a -y0aSDwZ3tZ2NLvf04Cw+nX9j0O8JQylsBdCWuDSI1FBZHTZ15dMO5yosL6giIx2V -O85XYmzQ94V/JBU9HC4wgBRs2H7oiRi2IbkXkuWQOlj1Rrqzh/tPTAQaASQmRxUi -ZvHUJg== +MIID1DCCArygAwIBAgIUU+CvNNI2Hg/kyKWUkP+fw3bsFe4wDQYJKoZIhvcNAQEL +BQAwEjEQMA4GA1UEAwwHTkFUUyBDQTAgFw0yNDA5MDYyMjMwMzZaGA8yMTI0MDgx +MzIyMzAzNlowgY4xCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJDQTEUMBIGA1UEBwwL +TG9zIEFuZ2VsZXMxDTALBgNVBAoMBE5BVFMxDTALBgNVBAsMBE5BVFMxEjAQBgNV +BAMMCWxvY2FsaG9zdDEUMBIGCgmSJomT8ixkARkWBGZvbzExFDASBgoJkiaJk/Is +ZAEZFgRmb28yMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAlLqkVfs1 +MsFP4PEOc+ovpiccxwl4zNVzyrt4Jlh7U030W0LbxnRYOZlhy/K4LxJHmJCvsp+j +ZhhTz8/LyQy8lc8+9GEKYtUL9gMHtGx04MJQlwClJR3xGqQ4d9OvIRKJ89hafJ+u +dgKzXaGihyQlGbSiH5tdHLPp1/nLor/ra3yVFWMT8q0Ibu5YVoTUcA1nnSN6XO9/ +NpsM3ksBX7dDItQMiuyYVTETOpXfdTF7iZSzXxyhHo67ppLenSD96O3CSRsVuCBY +w7OIISCvXHeiTHmEF7PQXNN4SmswigliE6zz4s9AQ+23oqhVDXD4Dpc6r3gZ6rF8 +kSxIxIkPWvUMAwIDAQABo4GiMIGfMF0GA1UdEQRWMFSCCWxvY2FsaG9zdIILZXhh +bXBsZS5jb22CD3d3dy5leGFtcGxlLmNvbYYpc3BpZmZlOi8vbG9jYWxob3N0L215 +LW5hdHMtc2VydmljZS91c2VyLWEwHQYDVR0OBBYEFDFDpnqTvAQQBUIBMzip3XCT +FdsTMB8GA1UdIwQYMBaAFCcUWYVGF5cPrQMR/VNkapjuXMRbMA0GCSqGSIb3DQEB +CwUAA4IBAQA8lg93kYHKkc4iF+mB8xHtyT1Pmy8CoxbDGy98cac1ny9s9K5kROTZ +rE9p2FaC00jf5T/+si5diXa0EnIjWCk0uRlrW5PL85UbsqHJkWav7zCk7cDa9YrR +nk4LMABf40RP3SOM4yxjjoVU13jFwIZ5M69Hce3CJ6ZkSoWRzWlKf6ECAbX/JIcJ +u8wLBXbJaAvc1CQiZpiSWDvItg+sUn1dU1nmk2o1YmyBPN6uVF874f3Ihazb9wmJ +dkWO48O+FaahjR6GzfjEx7w765ATqvTVYAgGZ55ps65VwfjcQbP1jYO4Sb3Aeeub +yapE1595oBWoWdwtEeOTJrzSIEhkhyiC -----END CERTIFICATE----- diff --git a/test/configs/certs/svid/client-b.key b/test/configs/certs/svid/client-b.key index 35d2f1118a..e620ec4860 100644 --- a/test/configs/certs/svid/client-b.key +++ b/test/configs/certs/svid/client-b.key @@ -1,28 +1,28 @@ -----BEGIN PRIVATE KEY----- -MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCW0fj0zXXf02oE -qgvsax+3ZaUikyVzNMw6T7oj08gQFwe3PAkNh7oXp+qFXBClr8g/irlIY4EAu/ak -+OhuizSjZHP9MHmVxo2TJGvGs3lAtjqDDYbTlRqUIH+0hX7jm10cY4wTkLSpV/oe -Dr4iE+ZXkr34+9KsFtZJCz1gTUC/L+oEIkbAs5G+HNuHMIgQBb6EWKvWsON8zzfx -XmAL0vhK0n3FmSQZSbPyyVzXfSifElSjwmgV7V+76xy5WQ29Pj1slMiwQNBfQJwK -wHZ9qWnlsjgigrf5qBiCbgTVJ2PLCMDZMXCTdhyfJWeOdSHFpW7xGSus0DgFGvep -c0vN4jCtAgMBAAECggEBAIcTt61I9vFoH+PdiKBNsTJITwYQU9JCz0bKcSP1YZFH -jxmFI3aCwSC+u0SFmENMlESUsi0rMTa/Ib/PThzzgEl2houVBtAl7FaEoCJuS4Kx -suX9D2wgdpWEJdxAU8z2MQZkAejkCWpB6TlSaueKexqjypFcuOp36aOx9V5y0jJo -D1uN0X2QhZ1ETe3L/chBO9tptjQcHsEz/ie5/J8qLXIa/txzh7eCvwpbsfTCmDhr -9bz1gQN/UdUpMgOgYLj5JbHiu0MaNzRsKCOWlVLTmqHx1IKWbr18egNZKdF1xoeP -+lndqUjKCXJMjzmcimJW5nur+g4EvuSMln7RzyPQJOECgYEAyJLzIExlAzDsOTio -t+T88EAfYQ2CZCmtAUloJSH2TLaOQAP8YyMrD96XYdDCApHShkFfy5HHIxRCkXRE -raj60fB2aimxCuvYPPFFrBWMV9+x6Q3lwOKr3PA0akHs64nAy6zNch2ACYI2Zsw3 -9uJv6mnvTD94oHoxdkuXfaCuJfcCgYEAwH9T3n41EnObJO6R83W94BxabqELzXV0 -faT15asP8Nr0gnXaJRZQXistSUlI0mdAX1rnfNSJy2CJNwU3qqvt3xFQPelQ4vCw -XjGGi4+JfWVOQ3orfeTd6f7LQP8vVuAUWDkFdXKzqoYbEIC7G+OWVqJeSjjEA4bQ -i2aLmS/A5XsCgYEAm8JyiCyLbTT63V0AuP5c5v4E4EurbLlons0w0VVUfjJuuYve -3eYbtNE5Yj7Jy1EO2i++gsoMiVNcdrSB+RJ25b4FV2BVGpQYcwsy/fYl7L/M251t -RKNCr+rh6XqU0D1DuWfSi8IZAklake4Zr+Ic4z+tE9teg9EgxCrj1C2Jz/UCgYAI -YsOdkrPvLNgaYMY86+kspS+PWDayaaZ8fr4zliMoo/E46bdqHDG+GHVtluK0P8k/ -Hi+tcXjbQkZX/kMxjTHcoN11BQAAEuosAE5TMBqWOt6Q8/aHEnxUYEQsfbFrQHHC -ciF5v1hyWks9ic4c5eo7tfETnKt1V98n43y7XKgzlwKBgGmckmzYv38biT6/PP0x -qJLqJATyApYuEiK9mN2G6/DTZMe4Y4DSOkZ0ijynHHtemJ9iXMTExquDYFwevdvG -vE6Frs5vqlQ9FzKe4Yb/D5rAxAjEULm3UtMJDgH2T1KiFhOFRJlTVyofLodhFjsa -oE8HdC7jrQgIJWINr0jpU0gw +MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQC7bOmV7/qGy+1L ++cgBawm55lxS2w8QQr/lZrq4k/plQC2UDRvGPDaIihbvbP+pfiAgfSiWd/s+Qhdr +oOL/gkAJo/iD8HYu9FN+Y4vPlJyoEguNJzOyRe7U9YnW+Gsefwr60PoeiKfXK5B8 +J5KahSQSka3hgW+yp4ECzAqpjobGUpzNoFVoQ0o9gBsvBWVOCJ02h5kcwsLFSSbh +h76FPiedKHtA3VAj+vrg7rYT4wHpmSAdJZ7uNvbjbB4Jv35ebTnlkywBcPJi3YGt +UI8O8HTDP1K8mlTitzvqHGMDtiT6OQJpffuJhOJ+PnXd4nOwKN+AAMQ8RxPx7lv5 +n2oYmq0vAgMBAAECggEAQNdYJIBGivXoHZ3HnP37+m2AyUVx+60sGGAm/w5q1TaT +ziGO11EjiK9FagWqmWfCE5tZPF079XkGAz1A6yaTowIwSu0Y5fuvGw2zY9hFLjw3 +9Nh4IRfinZho3I9K99z53nYH4iJi9qTisqE6Le0b4rS1lEukaglbL62Jjsl5RQje +EogelhVsVh1Lv2GxZw2GUZHogTuWK3ZW3objq6HE0oReS9vUDwSL/rwuOcrGFdnb +XkVD9Z+1eD8QD4Jp0rP0Abc8hkotb/alStbHTl3MzBEwVZXyc13HFDB4loOfhJU/ +bgPBgeFh1xXCR15+ouZsbsPkRZ5kwLSsbskUpkXeSQKBgQDe60LcdI0w7edfl3bl +pEOyA4Volh5net4dpQhLZFbjFAoTG1OA0Z9hBoZwoRLi1xkuMdLUzJOH6d9sBni2 +qn2sbHVKXTtb7Ie+RMb3XMpN34tlpqH2+vnrVkxkrPwWluhynVZm4AsefMHRAza2 +K3JBl2M+IAzgsfLUYNj4xWh35QKBgQDXPT5xjdr+NOADocrlf80w2iVnvLah0yVb +FgVenkX1u5ZUiv9calJagfaVQNm4VwxBXGr1/3+PoPdKNWFjnlPO8R1E3Eia1Iu+ +FberWhEpAJuctT+lcPS8sFDh4r5edgyOXE3ikuI4tDRsQErGATfWkIfmuKUThW2u +A8YZWmTXgwKBgQC0VUu0fhEOSRcIzMYhhh5BbvnIntCf09TF1JD+NIDZmIeB53RI +3Mt7OUUe7h8SJQI4zZOKFKkwpTDZ+e5Dj261QtQrwXpYpeM2N/thds4t6y6goAmc +fHIbQKfyNcKFH7WRqtiPxqUYF8LPLDNhcYovp6FgS5s/VpVj26kKruARRQKBgAP6 +Krw4bdKCsZz/kVs6SFVdwpEvKITG/Qq41nKQJCTNSZLYWq2ffVQU0LSjVSKV4TEX +/xX6maXSyJ8Da4BGva+2Pt813tWVldt2VUWCTYzfaQC1TK7G7o7KB0SVRwVB0yuS +QxIruqhnlAxoB7mu7hQ16Xz27n302jj78t4nEHP3AoGBAJMEOropyzzX3sYp4E9c +u+VPyqcEMXfFimh2il0hijgB17dSW2UXeoQ85gevbPfGURL7a549xar1cNgEfQO0 +T82PecgRs83SEcgHT4mntytGY/lsiowAQZ2rXtlyG4ADPwbQGV3UXqV1Bm7yBT38 +YJJKJNKjyMHA8auKGG37WDhu -----END PRIVATE KEY----- diff --git a/test/configs/certs/svid/client-b.pem b/test/configs/certs/svid/client-b.pem index 530cddcc84..3ae380ab59 100644 --- a/test/configs/certs/svid/client-b.pem +++ b/test/configs/certs/svid/client-b.pem @@ -1,19 +1,21 @@ -----BEGIN CERTIFICATE----- -MIIDHjCCAgagAwIBAgIUZ1mDw2Jbv4ZL87JpwO96ifyd+/EwDQYJKoZIhvcNAQEL -BQAwEjEQMA4GA1UEAwwHTkFUUyBDQTAeFw0yMjA5MDcyMDAzMjJaFw0yNDA5MDYy -MDAzMjJaMB0xCzAJBgNVBAYTAlVTMQ4wDAYDVQQKDAVTUElSRTCCASIwDQYJKoZI -hvcNAQEBBQADggEPADCCAQoCggEBAJbR+PTNdd/TagSqC+xrH7dlpSKTJXM0zDpP -uiPTyBAXB7c8CQ2Huhen6oVcEKWvyD+KuUhjgQC79qT46G6LNKNkc/0weZXGjZMk -a8azeUC2OoMNhtOVGpQgf7SFfuObXRxjjBOQtKlX+h4OviIT5leSvfj70qwW1kkL -PWBNQL8v6gQiRsCzkb4c24cwiBAFvoRYq9aw43zPN/FeYAvS+ErSfcWZJBlJs/LJ -XNd9KJ8SVKPCaBXtX7vrHLlZDb0+PWyUyLBA0F9AnArAdn2paeWyOCKCt/moGIJu -BNUnY8sIwNkxcJN2HJ8lZ451IcWlbvEZK6zQOAUa96lzS83iMK0CAwEAAaNhMF8w -XQYDVR0RBFYwVIIJbG9jYWxob3N0ggtleGFtcGxlLmNvbYIPd3d3LmV4YW1wbGUu -Y29thilzcGlmZmU6Ly9sb2NhbGhvc3QvbXktbmF0cy1zZXJ2aWNlL3VzZXItYjAN -BgkqhkiG9w0BAQsFAAOCAQEAvPSvD4OYwmdUrqoSalAZ3mjYs6RWpbY/w3sJvbM+ -/tk9fThNwPfzCC34Mn4oeYQorII+WjJ3q1H9SRS9nNxbipAhE5T6Jx7rV+sc52Uu -xjVoJlO/r0EoDD6mG4JXxfqxY6ZAIF5nsGiPIJ0oMPi91eVMJS3SCTrvxUmS0U6/ -21+aULSLaKZos0eDNINY8qWDWSNsZaSgFsC1zfLn1Y8i7WpPoiJWZAa981pNEuB1 -98kQOy2iP0yHE8dYCk4m2yQnSJfAWG7Hvdxrv7T8Erda0yv0wAam1AlVKKZ+57D6 -wf2Ufh+CsU1wFGQsCwDam7ht1xWjjkHs7E/Az3DRMri39Q== +MIIDYjCCAkqgAwIBAgIUU+CvNNI2Hg/kyKWUkP+fw3bsFe8wDQYJKoZIhvcNAQEL +BQAwEjEQMA4GA1UEAwwHTkFUUyBDQTAgFw0yNDA5MDYyMjMwMzZaGA8yMTI0MDgx +MzIyMzAzNlowHTELMAkGA1UEBhMCVVMxDjAMBgNVBAoMBVNQSVJFMIIBIjANBgkq +hkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAu2zple/6hsvtS/nIAWsJueZcUtsPEEK/ +5Wa6uJP6ZUAtlA0bxjw2iIoW72z/qX4gIH0olnf7PkIXa6Di/4JACaP4g/B2LvRT +fmOLz5ScqBILjSczskXu1PWJ1vhrHn8K+tD6Hoin1yuQfCeSmoUkEpGt4YFvsqeB +AswKqY6GxlKczaBVaENKPYAbLwVlTgidNoeZHMLCxUkm4Ye+hT4nnSh7QN1QI/r6 +4O62E+MB6ZkgHSWe7jb242weCb9+Xm055ZMsAXDyYt2BrVCPDvB0wz9SvJpU4rc7 +6hxjA7Yk+jkCaX37iYTifj513eJzsCjfgADEPEcT8e5b+Z9qGJqtLwIDAQABo4Gi +MIGfMF0GA1UdEQRWMFSCCWxvY2FsaG9zdIILZXhhbXBsZS5jb22CD3d3dy5leGFt +cGxlLmNvbYYpc3BpZmZlOi8vbG9jYWxob3N0L215LW5hdHMtc2VydmljZS91c2Vy +LWIwHQYDVR0OBBYEFAiaPOQsBb3+rAOlSevDy5kp7zCnMB8GA1UdIwQYMBaAFCcU +WYVGF5cPrQMR/VNkapjuXMRbMA0GCSqGSIb3DQEBCwUAA4IBAQBq7BxhZMCTl6Xe +i3GcPlOLp9JPP8bcyYZVB6nAf38eErpwYSPvp4I3IFU+KyZgtDIAb6Oy04BNV9eT +BlpX300ZbylO/TLCrlMIJDYLIt5NciVe8IxsE//uLXFq5wZpcCcL9aQA2g0wW8hi +pkK1dQd3W1ryR/LwKiy0fcZJw/EFskoqq6vPJATIFvH/O0OxdKP9T24YVGgLBzwj +xzUqVlU0CuP0snx6x4F3Oha6kJGwc90RlXszh2ELhO+o4sk4wtfAlEYaM+H3kbAK +lRe8FENyGprOjlxjy6N1noJW9Mgisx9kNcsCzW8auGY6l8Vs3wW3vO3n4ZUnq9qc +t95/tstH -----END CERTIFICATE----- diff --git a/test/configs/certs/svid/server.key b/test/configs/certs/svid/server.key index a2f1d24992..367f4d5d3c 100644 --- a/test/configs/certs/svid/server.key +++ b/test/configs/certs/svid/server.key @@ -1,28 +1,28 @@ -----BEGIN PRIVATE KEY----- -MIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQDNnmKam+59PJco -GDpJt8lR51KnRDkpHaQWuG+vyRVp3ovibleYawpw/jbTKpuOt1fo3YPdheW3A39+ -QN0W2om4i8bNZKhfP89T0FmJdMEtDpJztdwyEwLYVfDZHeFTjTdH1bQPXSnlDhX6 -OQxy4yUeTmFCeMbHU/4yZDuRAXKJLeJduntGXpigBtF6/4GRpGcddrYYsCrN5ZfL -rvWR89JCrNQbttkDQF2fH/1ClFy2gGFLUEmNMWdGOiYz1TLQcDSuWzXVzXqxOZ9R -O5niu69jXFFoI7MCk2JWgZuB2/zU4b0JumuCJRnQ+SzuJnNCvwiivCbSfn01imcv -j2EeE23zAgMBAAECggEBAMia5PKYfSX8LjD06jEvuJ9Kw03jdq0ReRydloF2+ohO -kkU4iAdxLz+sFUsR/7BOWdsb+uHuF37lT8aae9knH0RIQo3yzX4YICtSU3iSy0Et -PV7cp9bGy3jK5+67gzFjzfIsob53kz8g7foxHF8eEwGtUKBseurPnGoHdkHzmo4P -0R4YDzQIUVilxwZSPn48iLyHDse+8KoOHVus1/rtNjAU2nTfzQxVpzRjYOjQfb3A -yHz5ahXsISMBbVXrztrQyRm+wGSkyTAJAPKUERPoGYMizn422miF/OcCaDFBkRvm -QUnoZV8Np3c2srb1J435arcSGYmzteyU7LpYAoPEDeECgYEA7YP38yYnqJOoG3lc -j47+RX0/SsBU3gNc31+z9gBfC7LZ4sNFBdBk/aDwwKVkutJvxnU6PpSuZNr1muPw -baahwh9B7K2d37++Dt7bVjVJ2/sCJ/Pc/3JP2ShMVQ0TjnzwWwD5JfTGneetfpQ4 -Agj3miEnpSUi7UinTpGagGG7KwMCgYEA3Z7vY6mnz89Kj6IoC4I8BLClHFKWmEd0 -OiqSxLKOSftdx+tJnW9T6F7oCB6EBs9iD76i2lKyZPXckVYggxLl5e9QqHI7WFk5 -i56upPp2GadUuOQNpw3ZlMeRrKq9RFVoMw6IovermG9d5AUTNx0hwEEPMWvl9alA -UNZoS+QIRlECgYA/+EIor8cQpSwqsiYW2Cltp80LIf/5h6hU1R7QC8uNiA8c/wCx -Dy6UDOuqxyD5HEJUjjAwuLS7nyl1HR0dOzrn4KlNyHjz0V2r/aPPdSy+Xb136ztD -ZZNR5oOgiJQS1V2a9QkliuaPkt1scRkgmy+syG84EGd2xxGgnKCjIS9a5wKBgQCQ -Kjt/kXVgcXAHT2zNT8LLKj291tuv44tv6xHecmitJ58x1ZTlnO3wUwyNe4xXAcDA -jTpS20jA9E6vHF+55Ck5Ehxd9zEzn5cXg/oHyAXbWkZ6n59h9Fh9t/TDZa4JLaXC -0MmBeateVdO16Lc/OuwhrDC97XqB+7+i1layR3w6gQKBgQDYetW2BBYe2UG+X9xI -IZCxm/WPIVmoa6GRHXNkdKwZf5zJPQOXuE0IaLpn9sGxc1TD9LRwhGKyrJpbH404 -EiOQNnix1VAw3eT5zGB1hKLdThEb2CpMJjGVxVVQtZoErLRY7W2jqSjjv1qh5QGJ -mSARdVnJVczB3o3ngeDtQxxHtg== +MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCmmTq1fDtsMKVU +kc9jWb/JlOXU2i7s5uPzETulgrQRhHCWE6gACW3VYhTCecSf6TyLaFeTkwVsqv+r +teOld0gRyA/NdCN0fY04OGfr7eg3dDyK+ovGInP1rh+6UrMl2Y+Iy5n/lymFPFkd +EoqaKjXv5npGQScvrvTYN8hFu6ww3EdPI3rAYwolujGadbXttprLRIZvZQuYI30J +LydCVsFMwfm0lnegEHtr/lx2UbxXeyf9nIOle7UsPAdR7oRXomf5FCoXUuWajv3Q +W9NZEM4E0O2SbH/RO12MmmeXH0mwQuvrZAvgEtc8ZDMzmRZ+AOyCXxp6F7ME9SrB +pQqS7ljPAgMBAAECggEAFHvephXiUIkiquVKtJKCbEysfaFeB67T9Dz4Mn+BmG3K +UgmUrHx8TrJCjy7dqDPLR/DKY9C96ACWcwxoMx4ZdGY+2yoeeeI+DN2SmYWk+byG +/SeVLAVscJa6O/STJmI7rbwq8Swq5MDozBRNimsKOrcB7cVxBgHjBPrG2xwaLd+U +zExqarE89tfvtFVUQobyeOimcSEerMIkOngwtRxbhvF956VpvVEaJDsm1rHqeiZA +rKoky01IKMTXcf6g1bERKKXc/nPbMMOMYDD0FbQM5bK7OqSuN1+XFgLbIQOgShWv +OhlENsa8TttAUq6dst+bv+zxnXTLNhV1INEdJWgSQQKBgQDfUktQoMFRCfwnFCNJ +6r4jR108hLH7e8/2AfEJWAW8iwfvnpf4/fW7kqttcZ0FwLOGDb3TKJbXx0Jlz3Fr +bkD3BIb3+19ludqI+hZanoSUqXBt/iTWRJpOGwpoLSIGNCR01GePMCva5MvETPj5 +nh7la+6AXngvxx8cR7RJMcxAMQKBgQC++hLaJ+cec3YpJGAAIFnXRgtFyzKn+ToE +TvcbJEtHn1HO1MLJhd3E04A0BufjglxJ16Kpc95252O8GyveIKm408vbXjIY3Fxa +y0zlnUB3UNdZ21HdZU3vr8T0C2s1c6tKTStuxUjtzfu1LXElJp/MxfodnyL0UE4L +OiOmza7o/wKBgQC17uY6rmwvaDILaCWDn4D9XrM/jV8uYOTAJz7F/PbXbnCtrwdi +KwtZn5iXFdr1h9L5YBKIh2W0LroSFVjyS6UTWJXYSuqiBjJaK1uwwbmDHzLf+Q7r +nIIVJYRp8HLqmOomX7Bqf7UKpCC5MHgZa88B2tc3rz68tbzLnkLq6m3a0QKBgQCL +8MVVtH2oE6VXGn96ODp9A6eI+g/hhD/eHlr2OY8sKXOR4tflQcGy0+SSuyi6zrB/ +r5JTJ0Oxz3aGxUZM25RiilhMI+cDzp2iLmznqGYvyD41av+/AtesNhlVVvS1U1AF +/yw/XDNHhnPWXDkXpwjbzYqsoArGCf5WPcEYHon30wKBgDhFrftmpc8AgXoCDaAN +Ymb23qURm8m/+FTc+49xX3F/Lk2stW36M1Q2d0Liu30DTj1Yzkeb62ROycCdMN4l +SG87HwV0A2Fs4lAKhaYhd505+3keNg+tAr5puySRaysaT6S9uw9QsoskA8+AZzq4 +mzR28luIuvUmtSP+UBrQ6hyW -----END PRIVATE KEY----- diff --git a/test/configs/certs/svid/server.pem b/test/configs/certs/svid/server.pem index a9a21133fd..35b2bb41e8 100644 --- a/test/configs/certs/svid/server.pem +++ b/test/configs/certs/svid/server.pem @@ -1,18 +1,19 @@ -----BEGIN CERTIFICATE----- -MIIC6jCCAdKgAwIBAgIUZ1mDw2Jbv4ZL87JpwO96ifyd+/IwDQYJKoZIhvcNAQEL -BQAwEjEQMA4GA1UEAwwHTkFUUyBDQTAeFw0yMjA5MDcyMDAzMjNaFw0yNDA5MDYy -MDAzMjNaMBQxEjAQBgNVBAMMCWxvY2FsaG9zdDCCASIwDQYJKoZIhvcNAQEBBQAD -ggEPADCCAQoCggEBAM2eYpqb7n08lygYOkm3yVHnUqdEOSkdpBa4b6/JFWnei+Ju -V5hrCnD+NtMqm463V+jdg92F5bcDf35A3RbaibiLxs1kqF8/z1PQWYl0wS0OknO1 -3DITAthV8Nkd4VONN0fVtA9dKeUOFfo5DHLjJR5OYUJ4xsdT/jJkO5EBcokt4l26 -e0ZemKAG0Xr/gZGkZx12thiwKs3ll8uu9ZHz0kKs1Bu22QNAXZ8f/UKUXLaAYUtQ -SY0xZ0Y6JjPVMtBwNK5bNdXNerE5n1E7meK7r2NcUWgjswKTYlaBm4Hb/NThvQm6 -a4IlGdD5LO4mc0K/CKK8JtJ+fTWKZy+PYR4TbfMCAwEAAaM2MDQwMgYDVR0RBCsw -KYIJbG9jYWxob3N0ggtleGFtcGxlLmNvbYIPd3d3LmV4YW1wbGUuY29tMA0GCSqG -SIb3DQEBCwUAA4IBAQBUznac2moxZv8GirUUcsl9MBGvqs8NuA9Ihezn9819WNmR -155cw5lpcXFDaMVv5KN7T+q5mbIp6Z9ZH4SxRNvxWLH2yi2WtykPAqjWzHsKIwxk -u4uxwJGmWthr5dsqQpzgtG0V0FL4qpvK8EsW2ndAIKLX5m/6GRTAxW+Crq1KJhMb -aU7VtG44oH8LjXN9Me02GIME3QntL45ks93Q2zVELeHOj4YGeKLEaZvVTCa8Czgy -Nf8Md6WrQeM6BPK9zsDSk+TeuX39LUaRGyKlL4xC7RM+BVyVxcoiYFay8JV4ArTQ -nmSb5B5Dfwm8bkd+1Xm+ZI+nvhKrQDHM2o3nBcB3 +MIIDLDCCAhSgAwIBAgIUU+CvNNI2Hg/kyKWUkP+fw3bsFe0wDQYJKoZIhvcNAQEL +BQAwEjEQMA4GA1UEAwwHTkFUUyBDQTAgFw0yNDA5MDYyMjMwMzZaGA8yMTI0MDgx +MzIyMzAzNlowFDESMBAGA1UEAwwJbG9jYWxob3N0MIIBIjANBgkqhkiG9w0BAQEF +AAOCAQ8AMIIBCgKCAQEAppk6tXw7bDClVJHPY1m/yZTl1Nou7Obj8xE7pYK0EYRw +lhOoAAlt1WIUwnnEn+k8i2hXk5MFbKr/q7XjpXdIEcgPzXQjdH2NODhn6+3oN3Q8 +ivqLxiJz9a4fulKzJdmPiMuZ/5cphTxZHRKKmio17+Z6RkEnL6702DfIRbusMNxH +TyN6wGMKJboxmnW17baay0SGb2ULmCN9CS8nQlbBTMH5tJZ3oBB7a/5cdlG8V3sn +/ZyDpXu1LDwHUe6EV6Jn+RQqF1Llmo790FvTWRDOBNDtkmx/0TtdjJpnlx9JsELr +62QL4BLXPGQzM5kWfgDsgl8aehezBPUqwaUKku5YzwIDAQABo3YwdDAyBgNVHREE +KzApgglsb2NhbGhvc3SCC2V4YW1wbGUuY29tgg93d3cuZXhhbXBsZS5jb20wHQYD +VR0OBBYEFO2EJhb54LzOxx6W7lqphByWFT8pMB8GA1UdIwQYMBaAFCcUWYVGF5cP +rQMR/VNkapjuXMRbMA0GCSqGSIb3DQEBCwUAA4IBAQA86URTSVJU6k6VjcnT9Fzh +fnid+OV2NPoKzczw4pTc7aGjkZxtCD1ENlYhHlcni0ZFMIRtLiDARjwhBkVJ5S84 +1NS5l4J86ymazkSFZ27m8y0UeSDuPxZJFA/yBAmt/BoKRNMAAmonepdx73JpbiGE +yMD9RU5qI2E6BGo0B2khRYuY+POPFGPueVbqg3qR+LJPlxp8OIet9HGagEcUK7lG +PeFNKSUCfmuHHD/QO/gmG4ZM9/qB7M3McYh4/+CIihEmhfVK9Odo6Fs0t5MQdcEo +v6++7DlnpwRnmgC8GtEBMK5XJAILb6cI11TearTphFoP7xpvz0VHp3Gy9mA5cdwx -----END CERTIFICATE-----