Add compression helpers

authnrequest.go

@@ -24,6 +24,26 @@ import (
 	"github.com/RobotsAndPencils/go-saml/util"
 )
 
+func ParseCompressedEncodedRequest(b64RequestXML string) (*AuthnRequest, error) {
+	var authnRequest AuthnRequest
+	compressedXML, err := base64.StdEncoding.DecodeString(b64RequestXML)
+	if err != nil {
+		return nil, err
+	}
+	bXML := util.Decompress(compressedXML)
+
+	err = xml.Unmarshal(bXML, &authnRequest)
+	if err != nil {
+		return nil, err
+	}
+
+	// There is a bug with XML namespaces in Go that's causing XML attributes with colons to not be roundtrip
+	// marshal and unmarshaled so we'll keep the original string around for validation.
+	authnRequest.originalString = string(bXML)
+	return &authnRequest, nil
+
+}
+
 func ParseEncodedRequest(b64RequestXML string) (*AuthnRequest, error) {
 	authnRequest := AuthnRequest{}
 	bytesXML, err := base64.StdEncoding.DecodeString(b64RequestXML)
@@ -227,3 +247,13 @@ func (r *AuthnRequest) EncodedSignedString(privateKeyPath string) (string, error
 	b64XML := base64.StdEncoding.EncodeToString([]byte(signed))
 	return b64XML, nil
 }
+
+func (r *AuthnRequest) CompressedEncodedSignedString(privateKeyPath string) (string, error) {
+	signed, err := r.SignedString(privateKeyPath)
+	if err != nil {
+		return "", err
+	}
+	compressed := util.Compress([]byte(signed))
+	b64XML := base64.StdEncoding.EncodeToString(compressed)
+	return b64XML, nil
+}

authnresponse.go

@@ -9,6 +9,25 @@ import (
 	"github.com/RobotsAndPencils/go-saml/util"
 )
 
+func ParseCompressedEncodedResponse(b64ResponseXML string) (*Response, error) {
+	authnResponse := Response{}
+	compressedXML, err := base64.StdEncoding.DecodeString(b64ResponseXML)
+	if err != nil {
+		return nil, err
+	}
+	bXML := util.Decompress(compressedXML)
+	err = xml.Unmarshal(bXML, &authnResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	// There is a bug with XML namespaces in Go that's causing XML attributes with colons to not be roundtrip
+	// marshal and unmarshaled so we'll keep the original string around for validation.
+	authnResponse.originalString = string(bXML)
+	return &authnResponse, nil
+
+}
+
 func ParseEncodedResponse(b64ResponseXML string) (*Response, error) {
 	response := Response{}
 	bytesXML, err := base64.StdEncoding.DecodeString(b64ResponseXML)
@@ -276,6 +295,16 @@ func (r *Response) EncodedSignedString(privateKeyPath string) (string, error) {
 	return b64XML, nil
 }
 
+func (r *Response) CompressedEncodedSignedString(privateKeyPath string) (string, error) {
+	signed, err := r.SignedString(privateKeyPath)
+	if err != nil {
+		return "", err
+	}
+	compressed := util.Compress([]byte(signed))
+	b64XML := base64.StdEncoding.EncodeToString(compressed)
+	return b64XML, nil
+}
+
 // GetAttribute by Name or by FriendlyName. Return blank string if not found
 func (r *Response) GetAttribute(name string) string {
 	for _, attr := range r.Assertion.AttributeStatement.Attributes {

util/compress.go

@@ -0,0 +1,40 @@
+package util
+
+import (
+	"bytes"
+	"compress/flate"
+	"io"
+	"strings"
+)
+
+func CompressString(in string) string {
+	buf := new(bytes.Buffer)
+	compressor, _ := flate.NewWriter(buf, 9)
+	compressor.Write([]byte(in))
+	compressor.Close()
+	return buf.String()
+}
+
+func DecompressString(in string) string {
+	buf := new(bytes.Buffer)
+	decompressor := flate.NewReader(strings.NewReader(in))
+	io.Copy(buf, decompressor)
+	decompressor.Close()
+	return buf.String()
+}
+
+func Compress(in []byte) []byte {
+	buf := new(bytes.Buffer)
+	compressor, _ := flate.NewWriter(buf, 9)
+	compressor.Write(in)
+	compressor.Close()
+	return buf.Bytes()
+}
+
+func Decompress(in []byte) []byte {
+	buf := new(bytes.Buffer)
+	decompressor := flate.NewReader(bytes.NewReader(in))
+	io.Copy(buf, decompressor)
+	decompressor.Close()
+	return buf.Bytes()
+}

util/compress_test.go

@@ -0,0 +1,23 @@
+package util
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCompressString(t *testing.T) {
+	expected := "This is the test string"
+	compressed := CompressString(expected)
+	decompressed := DecompressString(compressed)
+	assert.Equal(t, expected, decompressed)
+	assert.True(t, len(compressed) > len(decompressed))
+}
+
+func TestCompress(t *testing.T) {
+	expected := []byte("This is the test string")
+	compressed := Compress(expected)
+	decompressed := Decompress(compressed)
+	assert.Equal(t, expected, decompressed)
+	assert.True(t, len(compressed) > len(decompressed))
+}