mirror of
https://github.com/hanzos3/madmin-go.git
synced 2026-10-30 20:35:32 +00:00
447 lines
9.5 KiB
Go
447 lines
9.5 KiB
Go
//
|
|
// Copyright (c) 2015-2024 MinIO, Inc.
|
|
//
|
|
// This file is part of MinIO Object Storage stack
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as
|
|
// published by the Free Software Foundation, either version 3 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
//
|
|
|
|
package estream
|
|
|
|
import (
|
|
"bytes"
|
|
crand "crypto/rand"
|
|
"crypto/rsa"
|
|
"io"
|
|
"os"
|
|
"testing"
|
|
)
|
|
|
|
var testStreams = map[string][]byte{
|
|
"stream1": bytes.Repeat([]byte("a"), 2000),
|
|
"stream2": bytes.Repeat([]byte("b"), 1<<20),
|
|
"stream3": bytes.Repeat([]byte("b"), 5),
|
|
"empty": {},
|
|
}
|
|
|
|
func TestStreamRoundtrip(t *testing.T) {
|
|
var buf bytes.Buffer
|
|
w := NewWriter(&buf)
|
|
if err := w.AddKeyPlain(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
wantStreams := 0
|
|
wantDecStreams := 0
|
|
for name, value := range testStreams {
|
|
st, err := w.AddEncryptedStream(name, []byte(name))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
_, err = io.Copy(st, bytes.NewBuffer(value))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
st.Close()
|
|
st, err = w.AddUnencryptedStream(name, []byte(name))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
_, err = io.Copy(st, bytes.NewBuffer(value))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
st.Close()
|
|
wantStreams += 2
|
|
wantDecStreams += 2
|
|
}
|
|
|
|
priv, err := rsa.GenerateKey(crand.Reader, 2048)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
err = w.AddKeyEncrypted(&priv.PublicKey)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for name, value := range testStreams {
|
|
st, err := w.AddEncryptedStream(name, []byte(name))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
_, err = io.Copy(st, bytes.NewBuffer(value))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
st.Close()
|
|
st, err = w.AddUnencryptedStream(name, []byte(name))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
_, err = io.Copy(st, bytes.NewBuffer(value))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
st.Close()
|
|
wantStreams += 2
|
|
wantDecStreams++
|
|
}
|
|
err = w.Close()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Read back...
|
|
b := buf.Bytes()
|
|
r, err := NewReader(bytes.NewBuffer(b))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
r.SetPrivateKey(priv)
|
|
|
|
var gotStreams int
|
|
for {
|
|
st, err := r.NextStream()
|
|
if err == io.EOF {
|
|
break
|
|
}
|
|
if err != nil {
|
|
t.Fatalf("stream %d: %v", gotStreams, err)
|
|
}
|
|
want, ok := testStreams[st.Name]
|
|
if !ok {
|
|
t.Fatal("unexpected stream name", st.Name)
|
|
}
|
|
if !bytes.Equal(st.Extra, []byte(st.Name)) {
|
|
t.Fatal("unexpected stream extra:", st.Extra)
|
|
}
|
|
got, err := io.ReadAll(st)
|
|
if err != nil {
|
|
t.Fatalf("stream %d: %v", gotStreams, err)
|
|
}
|
|
if !bytes.Equal(got, want) {
|
|
t.Errorf("stream %d: content mismatch (len %d,%d)", gotStreams, len(got), len(want))
|
|
}
|
|
gotStreams++
|
|
}
|
|
if gotStreams != wantStreams {
|
|
t.Errorf("want %d streams, got %d", wantStreams, gotStreams)
|
|
}
|
|
|
|
// Read back, but skip encrypted streams.
|
|
r, err = NewReader(bytes.NewBuffer(b))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
r.SkipEncrypted(true)
|
|
|
|
gotStreams = 0
|
|
for {
|
|
st, err := r.NextStream()
|
|
if err == io.EOF {
|
|
break
|
|
}
|
|
if err != nil {
|
|
t.Fatalf("stream %d: %v", gotStreams, err)
|
|
}
|
|
want, ok := testStreams[st.Name]
|
|
if !ok {
|
|
t.Fatal("unexpected stream name", st.Name)
|
|
}
|
|
if !bytes.Equal(st.Extra, []byte(st.Name)) {
|
|
t.Fatal("unexpected stream extra:", st.Extra)
|
|
}
|
|
got, err := io.ReadAll(st)
|
|
if err != nil {
|
|
t.Fatalf("stream %d: %v", gotStreams, err)
|
|
}
|
|
if !bytes.Equal(got, want) {
|
|
t.Errorf("stream %d: content mismatch (len %d,%d)", gotStreams, len(got), len(want))
|
|
}
|
|
gotStreams++
|
|
}
|
|
if gotStreams != wantDecStreams {
|
|
t.Errorf("want %d streams, got %d", wantStreams, gotStreams)
|
|
}
|
|
|
|
gotStreams = 0
|
|
r, err = NewReader(bytes.NewBuffer(b))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
r.SkipEncrypted(true)
|
|
for {
|
|
st, err := r.NextStream()
|
|
if err == io.EOF {
|
|
break
|
|
}
|
|
if err != nil {
|
|
t.Fatalf("stream %d: %v", gotStreams, err)
|
|
}
|
|
_, ok := testStreams[st.Name]
|
|
if !ok {
|
|
t.Fatal("unexpected stream name", st.Name)
|
|
}
|
|
if !bytes.Equal(st.Extra, []byte(st.Name)) {
|
|
t.Fatal("unexpected stream extra:", st.Extra)
|
|
}
|
|
err = st.Skip()
|
|
if err != nil {
|
|
t.Fatalf("stream %d: %v", gotStreams, err)
|
|
}
|
|
gotStreams++
|
|
}
|
|
if gotStreams != wantDecStreams {
|
|
t.Errorf("want %d streams, got %d", wantDecStreams, gotStreams)
|
|
}
|
|
|
|
if false {
|
|
r, err = NewReader(bytes.NewBuffer(b))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
r.SkipEncrypted(true)
|
|
|
|
err = r.DebugStream(os.Stdout)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestReplaceKeys(t *testing.T) {
|
|
var buf bytes.Buffer
|
|
w := NewWriter(&buf)
|
|
if err := w.AddKeyPlain(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
wantStreams := 0
|
|
for name, value := range testStreams {
|
|
st, err := w.AddEncryptedStream(name, []byte(name))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
_, err = io.Copy(st, bytes.NewBuffer(value))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
st.Close()
|
|
st, err = w.AddUnencryptedStream(name, []byte(name))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
_, err = io.Copy(st, bytes.NewBuffer(value))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
st.Close()
|
|
wantStreams += 2
|
|
}
|
|
|
|
priv, err := rsa.GenerateKey(crand.Reader, 2048)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
err = w.AddKeyEncrypted(&priv.PublicKey)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for name, value := range testStreams {
|
|
st, err := w.AddEncryptedStream(name, []byte(name))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
_, err = io.Copy(st, bytes.NewBuffer(value))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
st.Close()
|
|
st, err = w.AddUnencryptedStream(name, []byte(name))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
_, err = io.Copy(st, bytes.NewBuffer(value))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
st.Close()
|
|
wantStreams += 2
|
|
}
|
|
err = w.Close()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
priv2, err := rsa.GenerateKey(crand.Reader, 2048)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
var replaced bytes.Buffer
|
|
err = ReplaceKeys(&replaced, &buf, func(key *rsa.PublicKey) (*rsa.PrivateKey, *rsa.PublicKey) {
|
|
if key == nil {
|
|
return nil, &priv2.PublicKey
|
|
}
|
|
if key.Equal(&priv.PublicKey) {
|
|
return priv, &priv2.PublicKey
|
|
}
|
|
t.Fatal("unknown key\n", *key, "\nwant\n", priv.PublicKey)
|
|
return nil, nil
|
|
}, ReplaceKeysOptions{EncryptAll: true})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Read back...
|
|
r, err := NewReader(&replaced)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Use key provider.
|
|
r.PrivateKeyProvider(func(key *rsa.PublicKey) *rsa.PrivateKey {
|
|
if key.Equal(&priv2.PublicKey) {
|
|
return priv2
|
|
}
|
|
t.Fatal("unexpected public key")
|
|
return nil
|
|
})
|
|
|
|
var gotStreams int
|
|
for {
|
|
st, err := r.NextStream()
|
|
if err == io.EOF {
|
|
break
|
|
}
|
|
if err != nil {
|
|
t.Fatalf("stream %d: %v", gotStreams, err)
|
|
}
|
|
want, ok := testStreams[st.Name]
|
|
if !ok {
|
|
t.Fatal("unexpected stream name", st.Name)
|
|
}
|
|
if st.SentEncrypted != (gotStreams&1 == 0) {
|
|
t.Errorf("stream %d was sent with unexpected encryption %v", gotStreams, st.SentEncrypted)
|
|
}
|
|
if !bytes.Equal(st.Extra, []byte(st.Name)) {
|
|
t.Fatal("unexpected stream extra:", st.Extra)
|
|
}
|
|
got, err := io.ReadAll(st)
|
|
if err != nil {
|
|
t.Fatalf("stream %d: %v", gotStreams, err)
|
|
}
|
|
if !bytes.Equal(got, want) {
|
|
t.Errorf("stream %d: content mismatch (len %d,%d)", gotStreams, len(got), len(want))
|
|
}
|
|
gotStreams++
|
|
}
|
|
if gotStreams != wantStreams {
|
|
t.Errorf("want %d streams, got %d", wantStreams, gotStreams)
|
|
}
|
|
}
|
|
|
|
func TestError(t *testing.T) {
|
|
var buf bytes.Buffer
|
|
w := NewWriter(&buf)
|
|
if err := w.AddKeyPlain(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
want := "an error message!"
|
|
if err := w.AddError(want); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
w.Close()
|
|
|
|
// Read back...
|
|
r, err := NewReader(&buf)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
st, err := r.NextStream()
|
|
if err == nil {
|
|
t.Fatalf("did not receive error, got %v, err: %v", st, err)
|
|
}
|
|
if err.Error() != want {
|
|
t.Errorf("Expected %q, got %q", want, err.Error())
|
|
}
|
|
}
|
|
|
|
func TestStreamReturnNonDecryptable(t *testing.T) {
|
|
var buf bytes.Buffer
|
|
w := NewWriter(&buf)
|
|
if err := w.AddKeyPlain(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
priv, err := rsa.GenerateKey(crand.Reader, 2048)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
err = w.AddKeyEncrypted(&priv.PublicKey)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
wantStreams := len(testStreams)
|
|
for name, value := range testStreams {
|
|
st, err := w.AddEncryptedStream(name, []byte(name))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
_, err = io.Copy(st, bytes.NewBuffer(value))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
st.Close()
|
|
}
|
|
err = w.Close()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Read back...
|
|
b := buf.Bytes()
|
|
r, err := NewReader(bytes.NewBuffer(b))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
r.ReturnNonDecryptable(true)
|
|
gotStreams := 0
|
|
for {
|
|
st, err := r.NextStream()
|
|
if err == io.EOF {
|
|
break
|
|
}
|
|
if err != ErrNoKey {
|
|
t.Fatalf("stream %d: %v", gotStreams, err)
|
|
}
|
|
_, ok := testStreams[st.Name]
|
|
if !ok {
|
|
t.Fatal("unexpected stream name", st.Name)
|
|
}
|
|
if !bytes.Equal(st.Extra, []byte(st.Name)) {
|
|
t.Fatal("unexpected stream extra:", st.Extra)
|
|
}
|
|
if !st.SentEncrypted {
|
|
t.Fatal("stream not marked as encrypted:", st.SentEncrypted)
|
|
}
|
|
err = st.Skip()
|
|
if err != nil {
|
|
t.Fatalf("stream %d: %v", gotStreams, err)
|
|
}
|
|
gotStreams++
|
|
}
|
|
if gotStreams != wantStreams {
|
|
t.Errorf("want %d streams, got %d", wantStreams, gotStreams)
|
|
}
|
|
}
|