Secure Multiparty Sum in malicious model using threshold encryption Suppose $n$ actors each hold a plaintext $p_i$. We wish to find $\sum p_i$, without leaking any information about individual $p_i$. Any actor (or any link in the network) could be controlled by an active adversary. More precisely, these protocols can be proved secure against a polynomial time bounded adversary who can corrupt a set of less than $n/2$ parties initially, and then make them behave as he likes, we say that the adversary is active.
In article Multiparty Computation from Threshold Homomorphic Encryption there is approach to multiparty computation (MPC) basing it on homomorphic threshold crypto-systems. I'm unsure how to make multiparty sum secure in malicious model (against less than $n/2$ active adversaries) following this approach. I'm under impression that it's quite simple:

each player uses additive homomorphic encryption to calculate ciphertext $E(p_i)$ of his own imput, sends the ciphertext to other parties and attach proof of plaintext knowledge to the ciphertext
verify proofs, add ciphertexts to calculate $E(\sum p_i)$
decrypt sum $E(\sum p_i)$ using threshold decryption to calculate $\sum p_i$

Could you confirm that what I described above is secure in malicious model (against less than $n/2$ active colluding adversaries)?
You are on the right track. However, as Ricky Demer points out in the comments, your suggestion would not work because the input is encrypted with different public keys. To fix this you need to use the properties of the threshold-encryption scheme. 

In a threshold-encryption scheme the players run a key-generation protocol in order to generate a common public key $pk$, and a secret sharing of the secret key $sk$. This means that while all players hold $pk$ no single player holds $sk$. I.e., all players can encrypt but no one can decrypt without the help of the other players. In order to decrypt the players run a special decryption protocol.  

So in other words your suggestion is almost correct, only the players do not hold different public encryption keys. To fix it you need to add an other step before step 1 where the players collaborate to generate keys. And in step 3 the players do not decrypt on their own. Instead they run a decryption protocol among each other. 

This works because you only want to compute a sum (i.e., you are only doing additions). However, in general you could compute any arithmetic function. The only problem is that since you are using a additively homomorphic encryption scheme, doing multiplication is not as simple as addition. This is solved by running a special multiplication protocol among the players for every multiplication. 

These days of course you could use a fully homomorphic threshold encryption scheme instead of a additively homomorphic one. In that case you would no longer need a special multiplication protocol. The reason why the authors of the paper you are linking to do not use a fully homomorphic scheme is simply that those were not invented when the paper was written.

This is just a rough description of course. For more detail I recommend you read the paper you linked to.