treewide: fix all ignored errors

Signed-off-by: Sumner Evans <[email protected]>

Author: sumnerevans

pkg/libsignalgo/groupsecretparams.go

@@ -31,10 +31,13 @@ import (
 
 type Randomness [C.SignalRANDOMNESS_LEN]byte
 
-func GenerateRandomness() (Randomness, error) {
+func GenerateRandomness() Randomness {
 	var randomness Randomness
 	_, err := rand.Read(randomness[:])
-	return randomness, err
+	if err != nil {
+		panic(err)
+	}
+	return randomness
 }
 
 type GroupMasterKey [C.SignalGROUP_MASTER_KEY_LEN]byte
@@ -46,11 +49,7 @@ type UUIDCiphertext [C.SignalUUID_CIPHERTEXT_LEN]byte
 type ProfileKeyCiphertext [C.SignalPROFILE_KEY_CIPHERTEXT_LEN]byte
 
 func GenerateGroupSecretParams() (GroupSecretParams, error) {
-	randomness, err := GenerateRandomness()
-	if err != nil {
-		return GroupSecretParams{}, err
-	}
-	return GenerateGroupSecretParamsWithRandomness(randomness)
+	return GenerateGroupSecretParamsWithRandomness(GenerateRandomness())
 }
 
 func GenerateGroupSecretParamsWithRandomness(randomness Randomness) (GroupSecretParams, error) {

pkg/signalmeow/groups.go

@@ -173,10 +173,9 @@ func (cli *Client) GetAuthorizationForToday(ctx context.Context, masterKey libsi
 		zlog.Err(err).Msg("DeriveGroupSecretParamsFromMasterKey error")
 		return nil, err
 	}
-	randomness, err := libsignalgo.GenerateRandomness()
 	authCredentialPresentation, err := libsignalgo.CreateAuthCredentialWithPniPresentation(
 		prodServerPublicParams,
-		randomness,
+		libsignalgo.GenerateRandomness(),
 		groupSecretParams,
 		*authCredential,
 	)

pkg/signalmeow/keys.go

@@ -95,6 +95,9 @@ func (cli *Client) GenerateAndRegisterPreKeys(ctx context.Context, uuidKind type
 	// Mark prekeys as registered
 	// (kyber prekeys don't have "mark as uploaded" we just assume they always are)
 	lastPreKeyID, err := preKeys[len(preKeys)-1].GetID()
+	if err != nil {
+		return fmt.Errorf("failed to get last prekey ID: %w", err)
+	}
 	err = cli.Store.PreKeyStoreExtras.MarkPreKeysAsUploaded(ctx, uuidKind, lastPreKeyID)
 
 	if err != nil {
@@ -316,6 +319,9 @@ func (cli *Client) FetchAndProcessPreKey(ctx context.Context, theirUUID uuid.UUI
 	}
 
 	rawIdentityKey, err := addBase64PaddingAndDecode(prekeyResponse.IdentityKey)
+	if err != nil {
+		return fmt.Errorf("error decoding identity key: %w", err)
+	}
 	identityKey, err := libsignalgo.DeserializeIdentityKey([]byte(rawIdentityKey))
 	if err != nil {
 		zlog.Err(err).Msg("Error deserializing identity key")
@@ -372,6 +378,9 @@ func (cli *Client) FetchAndProcessPreKey(ctx context.Context, theirUUID uuid.UUI
 				return err
 			}
 			kyberPreKeySignature, err = addBase64PaddingAndDecode(d.PQPreKey.Signature)
+			if err != nil {
+				return fmt.Errorf("error decoding kyber prekey signature: %w", err)
+			}
 		}
 
 		rawSignature, err := addBase64PaddingAndDecode(d.SignedPreKey.Signature)

pkg/signalmeow/provisioning.go

@@ -186,10 +186,19 @@ func PerformProvisioning(incomingCtx context.Context, deviceStore store.DeviceSt
 
 		// Store identity keys?
 		address, err := libsignalgo.NewUUIDAddress(device.ACI, uint(device.DeviceID))
+		if err != nil {
+			c <- ProvisioningResponse{
+				State: StateProvisioningError,
+				Err:   fmt.Errorf("error creating new address: %w", err),
+			}
+			return
+		}
 		_, err = device.IdentityStore.SaveIdentityKey(ctx, address, device.ACIIdentityKeyPair.GetIdentityKey())
 		if err != nil {
-			zlog.Err(err).Msg("error saving identity key")
-			c <- ProvisioningResponse{State: StateProvisioningError, Err: err}
+			c <- ProvisioningResponse{
+				State: StateProvisioningError,
+				Err:   fmt.Errorf("error saving identity key: %w", err),
+			}
 			return
 		}
 
@@ -202,8 +211,10 @@ func PerformProvisioning(incomingCtx context.Context, deviceStore store.DeviceSt
 		// Store our profile key
 		err = device.ProfileKeyStore.StoreProfileKey(ctx, data.ACI, profileKey)
 		if err != nil {
-			zlog.Err(err).Msg("error storing profile key")
-			c <- ProvisioningResponse{State: StateProvisioningError, Err: err}
+			c <- ProvisioningResponse{
+				State: StateProvisioningError,
+				Err:   fmt.Errorf("error storing profile key: %w", err),
+			}
 			return
 		}
 
@@ -214,11 +225,20 @@ func PerformProvisioning(incomingCtx context.Context, deviceStore store.DeviceSt
 		// TODO hacky client construction
 		cli := &Client{Store: device}
 		err = cli.GenerateAndRegisterPreKeys(ctx, types.UUIDKindACI)
+		if err != nil {
+			c <- ProvisioningResponse{
+				State: StateProvisioningError,
+				Err:   fmt.Errorf("error generating and registering ACI prekeys: %w", err),
+			}
+			return
+		}
 		err = cli.GenerateAndRegisterPreKeys(ctx, types.UUIDKindPNI)
 
 		if err != nil {
-			zlog.Err(err).Msg("error generating and registering prekeys")
-			c <- ProvisioningResponse{State: StateProvisioningError, Err: err}
+			c <- ProvisioningResponse{
+				State: StateProvisioningError,
+				Err:   fmt.Errorf("error generating and registering PNI prekeys: %w", err),
+			}
 			return
 		}
 
@@ -248,6 +268,9 @@ func startProvisioning(ctx context.Context, ws *websocket.Conn, provisioningCiph
 		// Decode provisioning UUID
 		provisioningUuid := &signalpb.ProvisioningUuid{}
 		err = proto.Unmarshal(msg.Request.Body, provisioningUuid)
+		if err != nil {
+			return "", fmt.Errorf("failed to unmarshal provisioning UUID: %w", err)
+		}
 
 		// Create provisioning URL
 		bytesKey, _ := pubKey.Serialize()

pkg/signalmeow/sending.go

@@ -274,6 +274,9 @@ func (cli *Client) buildSSMessageToSend(ctx context.Context, recipientAddress *l
 		cli.Store.SessionStore,
 		cli.Store.IdentityStore,
 	)
+	if err != nil {
+		return 0, nil, err
+	}
 	envelopeType = int(signalpb.Envelope_UNIDENTIFIED_SENDER)
 
 	return envelopeType, encryptedPayload, nil

pkg/signalmeow/store/device.go

@@ -74,6 +74,9 @@ func (d *Device) ClearDeviceKeys(ctx context.Context) error {
 		return nil
 	}
 	err := d.PreKeyStoreExtras.DeleteAllPreKeys(ctx)
+	if err != nil {
+		return err
+	}
 	err = d.SessionStoreExtras.RemoveAllSessions(ctx)
 	return err
 }

portal.go

@@ -682,13 +682,11 @@ func (portal *Portal) sendSignalMessage(ctx context.Context, msg *signalpb.Conte
 	log.Debug().Msg("Sending event to Signal")
 
 	// Check to see if portal.ChatID is a standard UUID (with dashes)
-	var err error
 	if portal.IsPrivateChat() {
 		// this is a 1:1 chat
 		result := sender.Client.SendMessage(ctx, portal.UserID(), msg)
 		if !result.WasSuccessful {
-			err = result.FailedSendResult.Error
-			log.Err(err).Msg("Error sending event to Signal")
+			return result.Error
 		}
 	} else {
 		// this is a group chat
@@ -715,14 +713,15 @@ func (portal *Portal) sendSignalMessage(ctx context.Context, msg *signalpb.Conte
 			log.Debug().Msg("No successes or failures - Probably sent to myself")
 		} else if len(result.SuccessfullySentTo) == 0 {
 			log.Error().Msg("Failed to send event to all members of Signal group")
-			err = errors.New("failed to send to any members of Signal group")
+			return errors.New("failed to send to any members of Signal group")
+
 		} else if len(result.SuccessfullySentTo) < totalRecipients {
 			log.Warn().Msg("Only sent event to some members of Signal group")
 		} else {
 			log.Debug().Msg("Sent event to all members of Signal group")
 		}
 	}
-	return err
+	return nil
 }
 
 func (portal *Portal) sendMessageStatusCheckpointSuccess(ctx context.Context, evt *event.Event) {