You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
321 lines
7.3 KiB
321 lines
7.3 KiB
package Seeder
|
|
|
|
import (
|
|
"encoding/base64"
|
|
|
|
"git.tovijaeschke.xyz/tovi/Envelope/Backend/Database"
|
|
|
|
"github.com/gofrs/uuid"
|
|
)
|
|
|
|
func seedMessage(
|
|
primaryUser, secondaryUser Database.User,
|
|
primaryUserAssociationKey, secondaryUserAssociationKey string,
|
|
i int,
|
|
) error {
|
|
var (
|
|
message Database.Message
|
|
messageData Database.MessageData
|
|
key, userKey AesKey
|
|
keyCiphertext []byte
|
|
plaintext string
|
|
dataCiphertext []byte
|
|
senderIDCiphertext []byte
|
|
err error
|
|
)
|
|
|
|
plaintext = "Test Message"
|
|
|
|
userKey, err = GenerateAesKey()
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
key, err = GenerateAesKey()
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
dataCiphertext, err = key.AesEncrypt([]byte(plaintext))
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
senderIDCiphertext, err = key.AesEncrypt([]byte(primaryUser.ID.String()))
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
if i%2 == 0 {
|
|
senderIDCiphertext, err = key.AesEncrypt([]byte(secondaryUser.ID.String()))
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
}
|
|
|
|
keyCiphertext, err = userKey.AesEncrypt(
|
|
[]byte(base64.StdEncoding.EncodeToString(key.Key)),
|
|
)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
messageData = Database.MessageData{
|
|
Data: base64.StdEncoding.EncodeToString(dataCiphertext),
|
|
SenderID: base64.StdEncoding.EncodeToString(senderIDCiphertext),
|
|
SymmetricKey: base64.StdEncoding.EncodeToString(keyCiphertext),
|
|
}
|
|
|
|
message = Database.Message{
|
|
MessageData: messageData,
|
|
SymmetricKey: base64.StdEncoding.EncodeToString(
|
|
EncryptWithPublicKey(userKey.Key, decodedPublicKey),
|
|
),
|
|
AssociationKey: primaryUserAssociationKey,
|
|
}
|
|
|
|
err = (&message).CreateMessage()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
message = Database.Message{
|
|
MessageData: messageData,
|
|
SymmetricKey: base64.StdEncoding.EncodeToString(
|
|
EncryptWithPublicKey(userKey.Key, decodedPublicKey),
|
|
),
|
|
AssociationKey: secondaryUserAssociationKey,
|
|
}
|
|
|
|
return (&message).CreateMessage()
|
|
}
|
|
|
|
func seedConversationDetail(key AesKey) (Database.ConversationDetail, error) {
|
|
var (
|
|
conversationDetail Database.ConversationDetail
|
|
name string
|
|
nameCiphertext []byte
|
|
falseCiphertext []byte
|
|
trueCiphertext []byte
|
|
err error
|
|
)
|
|
|
|
name = "Test Conversation"
|
|
|
|
nameCiphertext, err = key.AesEncrypt([]byte(name))
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
falseCiphertext, err = key.AesEncrypt([]byte("false"))
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
trueCiphertext, err = key.AesEncrypt([]byte("true"))
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
conversationDetail = Database.ConversationDetail{
|
|
Name: base64.StdEncoding.EncodeToString(nameCiphertext),
|
|
TwoUser: base64.StdEncoding.EncodeToString(falseCiphertext),
|
|
AdminAddMembers: base64.StdEncoding.EncodeToString(trueCiphertext),
|
|
AdminEditInfo: base64.StdEncoding.EncodeToString(trueCiphertext),
|
|
AdminSendMessages: base64.StdEncoding.EncodeToString(falseCiphertext),
|
|
}
|
|
|
|
err = (&conversationDetail).CreateConversationDetail()
|
|
return conversationDetail, err
|
|
}
|
|
|
|
func seedUserConversation(
|
|
user Database.User,
|
|
threadID uuid.UUID,
|
|
key AesKey,
|
|
) (Database.UserConversation, error) {
|
|
var (
|
|
messageThreadUser Database.UserConversation
|
|
conversationDetailIDCiphertext []byte
|
|
adminCiphertext []byte
|
|
err error
|
|
)
|
|
|
|
conversationDetailIDCiphertext, err = key.AesEncrypt([]byte(threadID.String()))
|
|
if err != nil {
|
|
return messageThreadUser, err
|
|
}
|
|
|
|
adminCiphertext, err = key.AesEncrypt([]byte("true"))
|
|
if err != nil {
|
|
return messageThreadUser, err
|
|
}
|
|
|
|
messageThreadUser = Database.UserConversation{
|
|
UserID: user.ID,
|
|
ConversationDetailID: base64.StdEncoding.EncodeToString(conversationDetailIDCiphertext),
|
|
Admin: base64.StdEncoding.EncodeToString(adminCiphertext),
|
|
SymmetricKey: base64.StdEncoding.EncodeToString(
|
|
EncryptWithPublicKey(key.Key, decodedPublicKey),
|
|
),
|
|
}
|
|
|
|
err = (&messageThreadUser).CreateUserConversation()
|
|
return messageThreadUser, err
|
|
}
|
|
|
|
func seedConversationDetailUser(
|
|
user Database.User,
|
|
conversationDetail Database.ConversationDetail,
|
|
associationKey uuid.UUID,
|
|
admin bool,
|
|
key AesKey,
|
|
) (Database.ConversationDetailUser, error) {
|
|
var (
|
|
conversationDetailUser Database.ConversationDetailUser
|
|
|
|
userIDCiphertext []byte
|
|
usernameCiphertext []byte
|
|
adminCiphertext []byte
|
|
associationKeyCiphertext []byte
|
|
publicKeyCiphertext []byte
|
|
|
|
adminString = "false"
|
|
|
|
err error
|
|
)
|
|
|
|
if admin {
|
|
adminString = "true"
|
|
}
|
|
|
|
userIDCiphertext, err = key.AesEncrypt([]byte(user.ID.String()))
|
|
if err != nil {
|
|
return conversationDetailUser, err
|
|
}
|
|
|
|
usernameCiphertext, err = key.AesEncrypt([]byte(user.Username))
|
|
if err != nil {
|
|
return conversationDetailUser, err
|
|
}
|
|
|
|
adminCiphertext, err = key.AesEncrypt([]byte(adminString))
|
|
if err != nil {
|
|
return conversationDetailUser, err
|
|
}
|
|
|
|
associationKeyCiphertext, err = key.AesEncrypt([]byte(associationKey.String()))
|
|
if err != nil {
|
|
return conversationDetailUser, err
|
|
}
|
|
|
|
publicKeyCiphertext, err = key.AesEncrypt([]byte(user.AsymmetricPublicKey))
|
|
if err != nil {
|
|
return conversationDetailUser, err
|
|
}
|
|
|
|
conversationDetailUser = Database.ConversationDetailUser{
|
|
ConversationDetailID: conversationDetail.ID,
|
|
UserID: base64.StdEncoding.EncodeToString(userIDCiphertext),
|
|
Username: base64.StdEncoding.EncodeToString(usernameCiphertext),
|
|
Admin: base64.StdEncoding.EncodeToString(adminCiphertext),
|
|
AssociationKey: base64.StdEncoding.EncodeToString(associationKeyCiphertext),
|
|
PublicKey: base64.StdEncoding.EncodeToString(publicKeyCiphertext),
|
|
}
|
|
|
|
err = (&conversationDetailUser).CreateConversationDetailUser()
|
|
|
|
return conversationDetailUser, err
|
|
}
|
|
|
|
// SeedMessages seeds messages & conversations for testing
|
|
func SeedMessages() {
|
|
var (
|
|
conversationDetail Database.ConversationDetail
|
|
key AesKey
|
|
primaryUser Database.User
|
|
primaryUserAssociationKey uuid.UUID
|
|
secondaryUser Database.User
|
|
secondaryUserAssociationKey uuid.UUID
|
|
i int
|
|
err error
|
|
)
|
|
|
|
key, err = GenerateAesKey()
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
conversationDetail, err = seedConversationDetail(key)
|
|
|
|
primaryUserAssociationKey, err = uuid.NewV4()
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
secondaryUserAssociationKey, err = uuid.NewV4()
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
primaryUser, err = Database.GetUserByUsername("testUser")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
_, err = seedUserConversation(
|
|
primaryUser,
|
|
conversationDetail.ID,
|
|
key,
|
|
)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
secondaryUser, err = Database.GetUserByUsername("ATestUser2")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
_, err = seedUserConversation(
|
|
secondaryUser,
|
|
conversationDetail.ID,
|
|
key,
|
|
)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
_, err = seedConversationDetailUser(
|
|
primaryUser,
|
|
conversationDetail,
|
|
primaryUserAssociationKey,
|
|
true,
|
|
key,
|
|
)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
_, err = seedConversationDetailUser(
|
|
secondaryUser,
|
|
conversationDetail,
|
|
secondaryUserAssociationKey,
|
|
false,
|
|
key,
|
|
)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
for i = 0; i <= 100; i++ {
|
|
err = seedMessage(
|
|
primaryUser,
|
|
secondaryUser,
|
|
primaryUserAssociationKey.String(),
|
|
secondaryUserAssociationKey.String(),
|
|
i,
|
|
)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
}
|
|
}
|