chore: added armor decode

bridge/call.go

@@ -64,6 +64,8 @@ func Call(name string, payload []byte) ([]byte, error) {
 		output = instance.generate(payload)
 	case "armorEncode":
 		output = instance.armorEncode(payload)
+	case "armorDecode":
+		output = instance.armorDecode(payload)
 	case "getPublicKeyMetadata":
 		output = instance.getPublicKeyMetadata(payload)
 	case "getPrivateKeyMetadata":
@@ -265,9 +267,16 @@ func (m instance) armorEncode(payload []byte) []byte {
 	response := flatbuffers.NewBuilder(0)
 	request := model.GetRootAsArmorEncodeRequest(payload, 0)
 
-	output, err := m.instance.ArmorEncode(request.PacketBytes())
+	output, err := m.instance.ArmorEncode(request.PacketBytes(), string(request.Type()))
 	return m._stringResponse(response, output, err)
 }
+func (m instance) armorDecode(payload []byte) []byte {
+	response := flatbuffers.NewBuilder(0)
+	request := model.GetRootAsArmorDecodeRequest(payload, 0)
+
+	output, err := m.instance.ArmorDecode(string(request.Message()))
+	return m._armorDecodeResponse(response, output, err)
+}
 
 func (m instance) getPublicKeyMetadata(payload []byte) []byte {
 	response := flatbuffers.NewBuilder(0)
@@ -441,6 +450,29 @@ func (m instance) parseCompression(input model.Compression) string {
 	}
 }
 
+func (m instance) _armorDecodeResponse(response *flatbuffers.Builder, output *openpgp.ArmorMetadata, err error) []byte {
+	if err != nil {
+		outputOffset := response.CreateString(err.Error())
+		model.ArmorDecodeResponseStart(response)
+		model.ArmorDecodeResponseAddError(response, outputOffset)
+		response.Finish(model.ArmorDecodeResponseEnd(response))
+		return response.FinishedBytes()
+	}
+
+	bodyOffset := response.CreateByteVector(output.Body)
+	typeOffset := response.CreateString(output.Type)
+
+	model.ArmorMetadataStart(response)
+	model.ArmorMetadataAddBody(response, bodyOffset)
+	model.ArmorMetadataAddType(response, typeOffset)
+	metadata := model.ArmorMetadataEnd(response)
+
+	model.ArmorDecodeResponseStart(response)
+	model.ArmorDecodeResponseAddOutput(response, metadata)
+	response.Finish(model.ArmorDecodeResponseEnd(response))
+	return response.FinishedBytes()
+}
+
 func (m instance) _keyPairResponse(response *flatbuffers.Builder, output *openpgp.KeyPair, err error) []byte {
 	if err != nil {
 		outputOffset := response.CreateString(err.Error())

flatbuffers/bridge.fbs

@@ -202,6 +202,11 @@ table GenerateRequest {
 
 table ArmorEncodeRequest {
   packet:[ubyte];
+  type:string;
+}
+
+table ArmorDecodeRequest {
+  message:string;
 }
 
 table GetPublicKeyMetadataRequest {
@@ -297,6 +302,16 @@ table IntResponse {
   error:string;
 }
 
+table ArmorDecodeResponse {
+  output:model.ArmorMetadata;
+  error:string;
+}
+
+table ArmorMetadata {
+  body:[ubyte];
+  type:string;
+}
+
 table KeyPairResponse {
   output:model.KeyPair;
   error:string;

openpgp/armor.go

@@ -2,10 +2,13 @@ package openpgp
 
 import (
 	"bytes"
+	"io/ioutil"
+	"strings"
+
 	"github.com/ProtonMail/go-crypto/openpgp/armor"
 )
 
-func (o *FastOpenPGP) ArmorEncode(packet []byte) (string, error) {
+func (o *FastOpenPGP) ArmorEncode(packet []byte, messageType string) (string, error) {
 	buf := bytes.NewBuffer(nil)
 	writer, err := armor.Encode(buf, messageType, headers)
 	if err != nil {
@@ -21,3 +24,17 @@ func (o *FastOpenPGP) ArmorEncode(packet []byte) (string, error) {
 	}
 	return buf.String(), nil
 }
+
+func (o *FastOpenPGP) ArmorDecode(message string) (*ArmorMetadata, error) {
+	block, err := armor.Decode(strings.NewReader(message))
+	if err != nil {
+		return nil, err
+	}
+
+	output, err := ioutil.ReadAll(block.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	return &ArmorMetadata{Body: output, Type: block.Type}, nil
+}

openpgp/armor_test.go

@@ -13,7 +13,7 @@ cmFuZG9tIHN0cmluZw==
 func TestFastOpenPGP_ArmorEncode(t *testing.T) {
 
 	openPGP := NewFastOpenPGP()
-	output, err := openPGP.ArmorEncode([]byte("random string"))
+	output, err := openPGP.ArmorEncode([]byte("random string"), messageType)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -24,3 +24,21 @@ func TestFastOpenPGP_ArmorEncode(t *testing.T) {
 		t.Fatal("not same input")
 	}
 }
+
+func TestFastOpenPGP_DecodeEncode(t *testing.T) {
+
+	openPGP := NewFastOpenPGP()
+	output, err := openPGP.ArmorDecode(encoded)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	t.Log("output:", output)
+
+	if output.Type != messageType {
+		t.Fatal("not same type:", output.Type)
+	}
+	if string(output.Body) != "random string" {
+		t.Fatal("not same input")
+	}
+}