diff options
Diffstat (limited to 'vendor/go.mau.fi/libsignal/serialize/JSONSerializer.go')
| -rw-r--r-- | vendor/go.mau.fi/libsignal/serialize/JSONSerializer.go | 303 |
1 files changed, 303 insertions, 0 deletions
diff --git a/vendor/go.mau.fi/libsignal/serialize/JSONSerializer.go b/vendor/go.mau.fi/libsignal/serialize/JSONSerializer.go new file mode 100644 index 00000000..1245fc42 --- /dev/null +++ b/vendor/go.mau.fi/libsignal/serialize/JSONSerializer.go @@ -0,0 +1,303 @@ +package serialize + +import ( + "encoding/json" + + groupRecord "go.mau.fi/libsignal/groups/state/record" + "go.mau.fi/libsignal/logger" + "go.mau.fi/libsignal/protocol" + "go.mau.fi/libsignal/state/record" +) + +// NewJSONSerializer will return a serializer for all Signal objects that will +// be responsible for converting objects to and from JSON bytes. +func NewJSONSerializer() *Serializer { + serializer := NewSerializer() + + serializer.SignalMessage = &JSONSignalMessageSerializer{} + serializer.PreKeySignalMessage = &JSONPreKeySignalMessageSerializer{} + serializer.SignedPreKeyRecord = &JSONSignedPreKeyRecordSerializer{} + serializer.PreKeyRecord = &JSONPreKeyRecordSerializer{} + serializer.State = &JSONStateSerializer{} + serializer.Session = &JSONSessionSerializer{} + serializer.SenderKeyMessage = &JSONSenderKeyMessageSerializer{} + serializer.SenderKeyDistributionMessage = &JSONSenderKeyDistributionMessageSerializer{} + serializer.SenderKeyRecord = &JSONSenderKeySessionSerializer{} + serializer.SenderKeyState = &JSONSenderKeyStateSerializer{} + + return serializer +} + +// JSONSignalMessageSerializer is a structure for serializing signal messages into +// and from JSON. +type JSONSignalMessageSerializer struct{} + +// Serialize will take a signal message structure and convert it to JSON bytes. +func (j *JSONSignalMessageSerializer) Serialize(signalMessage *protocol.SignalMessageStructure) []byte { + serialized, err := json.Marshal(*signalMessage) + if err != nil { + logger.Error("Error serializing signal message: ", err) + } + // logger.Debug("Serialize result: ", string(serialized)) + + return serialized +} + +// Deserialize will take in JSON bytes and return a signal message structure. +func (j *JSONSignalMessageSerializer) Deserialize(serialized []byte) (*protocol.SignalMessageStructure, error) { + var signalMessage protocol.SignalMessageStructure + err := json.Unmarshal(serialized, &signalMessage) + if err != nil { + logger.Error("Error deserializing signal message: ", err) + return nil, err + } + + return &signalMessage, nil +} + +// JSONPreKeySignalMessageSerializer is a structure for serializing prekey signal messages +// into and from JSON. +type JSONPreKeySignalMessageSerializer struct{} + +// Serialize will take a prekey signal message structure and convert it to JSON bytes. +func (j *JSONPreKeySignalMessageSerializer) Serialize(signalMessage *protocol.PreKeySignalMessageStructure) []byte { + serialized, err := json.Marshal(signalMessage) + if err != nil { + logger.Error("Error serializing prekey signal message: ", err) + } + // logger.Debug("Serialize result: ", string(serialized)) + + return serialized +} + +// Deserialize will take in JSON bytes and return a prekey signal message structure. +func (j *JSONPreKeySignalMessageSerializer) Deserialize(serialized []byte) (*protocol.PreKeySignalMessageStructure, error) { + var preKeySignalMessage protocol.PreKeySignalMessageStructure + err := json.Unmarshal(serialized, &preKeySignalMessage) + if err != nil { + logger.Error("Error deserializing prekey signal message: ", err) + return nil, err + } + + return &preKeySignalMessage, nil +} + +// JSONSignedPreKeyRecordSerializer is a structure for serializing signed prekey records +// into and from JSON. +type JSONSignedPreKeyRecordSerializer struct{} + +// Serialize will take a signed prekey record structure and convert it to JSON bytes. +func (j *JSONSignedPreKeyRecordSerializer) Serialize(signedPreKey *record.SignedPreKeyStructure) []byte { + serialized, err := json.Marshal(signedPreKey) + if err != nil { + logger.Error("Error serializing signed prekey record: ", err) + } + // logger.Debug("Serialize result: ", string(serialized)) + + return serialized +} + +// Deserialize will take in JSON bytes and return a signed prekey record structure. +func (j *JSONSignedPreKeyRecordSerializer) Deserialize(serialized []byte) (*record.SignedPreKeyStructure, error) { + var signedPreKeyStructure record.SignedPreKeyStructure + err := json.Unmarshal(serialized, &signedPreKeyStructure) + if err != nil { + logger.Error("Error deserializing signed prekey record: ", err) + return nil, err + } + + return &signedPreKeyStructure, nil +} + +// JSONPreKeyRecordSerializer is a structure for serializing prekey records +// into and from JSON. +type JSONPreKeyRecordSerializer struct{} + +// Serialize will take a prekey record structure and convert it to JSON bytes. +func (j *JSONPreKeyRecordSerializer) Serialize(preKey *record.PreKeyStructure) []byte { + serialized, err := json.Marshal(preKey) + if err != nil { + logger.Error("Error serializing prekey record: ", err) + } + // logger.Debug("Serialize result: ", string(serialized)) + + return serialized +} + +// Deserialize will take in JSON bytes and return a prekey record structure. +func (j *JSONPreKeyRecordSerializer) Deserialize(serialized []byte) (*record.PreKeyStructure, error) { + var preKeyStructure record.PreKeyStructure + err := json.Unmarshal(serialized, &preKeyStructure) + if err != nil { + logger.Error("Error deserializing prekey record: ", err) + return nil, err + } + + return &preKeyStructure, nil +} + +// JSONStateSerializer is a structure for serializing session states into +// and from JSON. +type JSONStateSerializer struct{} + +// Serialize will take a session state structure and convert it to JSON bytes. +func (j *JSONStateSerializer) Serialize(state *record.StateStructure) []byte { + serialized, err := json.Marshal(state) + if err != nil { + logger.Error("Error serializing session state: ", err) + } + logger.Debug("Serialize result: ", string(serialized)) + + return serialized +} + +// Deserialize will take in JSON bytes and return a session state structure. +func (j *JSONStateSerializer) Deserialize(serialized []byte) (*record.StateStructure, error) { + var stateStructure record.StateStructure + err := json.Unmarshal(serialized, &stateStructure) + if err != nil { + logger.Error("Error deserializing session state: ", err) + return nil, err + } + + return &stateStructure, nil +} + +// JSONSessionSerializer is a structure for serializing session records into +// and from JSON. +type JSONSessionSerializer struct{} + +// Serialize will take a session structure and convert it to JSON bytes. +func (j *JSONSessionSerializer) Serialize(session *record.SessionStructure) []byte { + serialized, err := json.Marshal(session) + if err != nil { + logger.Error("Error serializing session: ", err) + } + // logger.Debug("Serialize result: ", string(serialized)) + + return serialized +} + +// Deserialize will take in JSON bytes and return a session structure, which can be +// used to create a new Session Record object. +func (j *JSONSessionSerializer) Deserialize(serialized []byte) (*record.SessionStructure, error) { + var sessionStructure record.SessionStructure + err := json.Unmarshal(serialized, &sessionStructure) + if err != nil { + logger.Error("Error deserializing session: ", err) + return nil, err + } + + return &sessionStructure, nil +} + +// JSONSenderKeyDistributionMessageSerializer is a structure for serializing senderkey +// distribution records to and from JSON. +type JSONSenderKeyDistributionMessageSerializer struct{} + +// Serialize will take a senderkey distribution message and convert it to JSON bytes. +func (j *JSONSenderKeyDistributionMessageSerializer) Serialize(message *protocol.SenderKeyDistributionMessageStructure) []byte { + serialized, err := json.Marshal(message) + if err != nil { + logger.Error("Error serializing senderkey distribution message: ", err) + } + // logger.Debug("Serialize result: ", string(serialized)) + + return serialized +} + +// Deserialize will take in JSON bytes and return a message structure, which can be +// used to create a new SenderKey Distribution object. +func (j *JSONSenderKeyDistributionMessageSerializer) Deserialize(serialized []byte) (*protocol.SenderKeyDistributionMessageStructure, error) { + var msgStructure protocol.SenderKeyDistributionMessageStructure + err := json.Unmarshal(serialized, &msgStructure) + if err != nil { + logger.Error("Error deserializing senderkey distribution message: ", err) + return nil, err + } + + return &msgStructure, nil +} + +// JSONSenderKeyMessageSerializer is a structure for serializing senderkey +// messages to and from JSON. +type JSONSenderKeyMessageSerializer struct{} + +// Serialize will take a senderkey message and convert it to JSON bytes. +func (j *JSONSenderKeyMessageSerializer) Serialize(message *protocol.SenderKeyMessageStructure) []byte { + serialized, err := json.Marshal(message) + if err != nil { + logger.Error("Error serializing senderkey distribution message: ", err) + } + // logger.Debug("Serialize result: ", string(serialized)) + + return serialized +} + +// Deserialize will take in JSON bytes and return a message structure, which can be +// used to create a new SenderKey message object. +func (j *JSONSenderKeyMessageSerializer) Deserialize(serialized []byte) (*protocol.SenderKeyMessageStructure, error) { + var msgStructure protocol.SenderKeyMessageStructure + err := json.Unmarshal(serialized, &msgStructure) + if err != nil { + logger.Error("Error deserializing senderkey message: ", err) + return nil, err + } + + return &msgStructure, nil +} + +// JSONSenderKeyStateSerializer is a structure for serializing group session states into +// and from JSON. +type JSONSenderKeyStateSerializer struct{} + +// Serialize will take a session state structure and convert it to JSON bytes. +func (j *JSONSenderKeyStateSerializer) Serialize(state *groupRecord.SenderKeyStateStructure) []byte { + serialized, err := json.Marshal(state) + if err != nil { + logger.Error("Error serializing session state: ", err) + } + // logger.Debug("Serialize result: ", string(serialized)) + + return serialized +} + +// Deserialize will take in JSON bytes and return a session state structure. +func (j *JSONSenderKeyStateSerializer) Deserialize(serialized []byte) (*groupRecord.SenderKeyStateStructure, error) { + var stateStructure groupRecord.SenderKeyStateStructure + err := json.Unmarshal(serialized, &stateStructure) + if err != nil { + logger.Error("Error deserializing session state: ", err) + return nil, err + } + + return &stateStructure, nil +} + +// JSONSenderKeySessionSerializer is a structure for serializing session records into +// and from JSON. +type JSONSenderKeySessionSerializer struct{} + +// Serialize will take a session structure and convert it to JSON bytes. +func (j *JSONSenderKeySessionSerializer) Serialize(session *groupRecord.SenderKeyStructure) []byte { + serialized, err := json.Marshal(session) + if err != nil { + logger.Error("Error serializing session: ", err) + } + // logger.Debug("Serialize result: ", string(serialized)) + + return serialized +} + +// Deserialize will take in JSON bytes and return a session structure, which can be +// used to create a new Session Record object. +func (j *JSONSenderKeySessionSerializer) Deserialize(serialized []byte) (*groupRecord.SenderKeyStructure, error) { + var sessionStructure groupRecord.SenderKeyStructure + err := json.Unmarshal(serialized, &sessionStructure) + if err != nil { + logger.Error("Error deserializing session: ", err) + return nil, err + } + + return &sessionStructure, nil +} |