hoernschen/Matrix
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Wiki Activity

Finishing Prototype

Browse source
This commit is contained in:
Hoernschen 2020-10-17 12:07:39 +02:00
parent da9196f389
commit 473dc4a495
25 changed files with 1150 additions and 825 deletions
Download patch file Download diff file Expand all files Collapse all files

240
utils/database/databaseConnector.go
View file

@ -3,7 +3,6 @@ package database
import (
"database/sql"
"fmt"
"log"
_ "github.com/mattn/go-sqlite3"
)
@ -11,7 +10,6 @@ import (
var DB *sql.DB
func InitDB(filepath string) (err error) {
log.Printf("Init DB")
DB, err = sql.Open("sqlite3", filepath)
if err != nil {
panic(err)
@ -31,7 +29,6 @@ func InitDB(filepath string) (err error) {
}
func initDeviceTable() (err error) {
log.Printf("Init Device Table")
statement, err := DB.Prepare(`CREATE TABLE IF NOT EXISTS device (
id TEXT PRIMARY KEY,
name TEXT,
@ -43,47 +40,10 @@ func initDeviceTable() (err error) {
}
statement.Exec()
/*
newDevice := &device.Device{Id: "test", Name: "TEST", Keys: nil}
err = CreateDevice(db, newDevice, "test")
if err != nil {
log.Printf("Error Create: %s", err)
return
}
newDevice.Name = "TEST2"
err = UpdateDevice(db, newDevice)
if err != nil {
log.Printf("Error Update: %s", err)
return
}
devices, err := ReadDevicesForUser(db, "test")
if err != nil {
log.Printf("Error Read User: %s", err)
return
}
log.Println(devices)
err = DeleteDevice(db, newDevice.Id)
if err != nil {
log.Printf("Error Delete: %s", err)
return
}
de, err := ReadDevice(db, "test")
if err != nil {
log.Printf("Error Read: %s", err)
return
}
if de != nil {
log.Printf("Device ID: %s Name: %s", de.Id, de.Name)
} else {
log.Printf("No Device found")
}
*/
return
}
func initKeyTable() (err error) {
log.Printf("Init Key Table")
statement, err := DB.Prepare(`CREATE TABLE IF NOT EXISTS key (
id TEXT PRIMARY KEY,
type TEXT,
@ -94,46 +54,11 @@ func initKeyTable() (err error) {
return
}
statement.Exec()
/*
newKey := &device.Key{Id: "test", Type: "test", Key: "test"}
err = CreateKey(db, newKey, "test")
if err != nil {
log.Printf("Error Create: %s", err)
return
}
keys, err := ReadKeysForDevice(db, "test")
if err != nil {
log.Printf("Error Read Multiple: %s", err)
return
}
log.Println(keys)
newKey.Key = "TEST123"
err = UpdateKey(db, newKey)
if err != nil {
log.Printf("Error Update: %s", err)
return
}
err = DeleteKey(db, newKey.Id)
if err != nil {
log.Printf("Error Delete: %s", err)
return
}
readKey, err := ReadKey(db, "test")
if err != nil {
log.Printf("Error Read: %s", err)
return
}
if readKey != nil {
log.Printf("Key ID: %s Type: %s, Key: %s", readKey.Id, readKey.Type, readKey.Key)
} else {
log.Printf("No Key found")
}
*/
return
}
func initEventTable() (err error) {
log.Printf("Init Event Table")
statement, err := DB.Prepare(`CREATE TABLE IF NOT EXISTS event (
id TEXT PRIMARY KEY,
roomId TEXT,
@ -172,60 +97,11 @@ func initEventTable() (err error) {
return
}
statement.Exec()
/*
newEvent := &event.Event{
Id: "test",
RoomId: "test",
EventType: "test",
Content: "{TEST}",
ParentId: "test1",
Depth: 0,
}
err = CreateEvent(db, newEvent, "test")
if err != nil {
log.Printf("Error Create: %s", err)
return
}
eventsRoom, err := ReadEventsFromRoom(db, "test")
if err != nil {
log.Printf("Error Read User: %s", err)
return
}
log.Println(eventsRoom)
eventsTxn, err := ReadEventsFromTransaction(db, "test")
if err != nil {
log.Printf("Error Read User: %s", err)
return
}
log.Println(eventsTxn)
newEvent.Content = "{TEST123}"
err = UpdateEvent(db, newEvent)
if err != nil {
log.Printf("Error Update: %s", err)
return
}
err = DeleteEvent(db, newEvent.Id)
if err != nil {
log.Printf("Error Delete: %s", err)
return
}
readEvent, err := ReadEvent(db, "test")
if err != nil {
log.Printf("Error Read: %s", err)
return
}
if readEvent != nil {
log.Printf("Event ID: %s RoomId: %s EventType: %s Content: %s ParentId: %s Depth: %s",
readEvent.Id, readEvent.RoomId, readEvent.EventType, readEvent.Content, readEvent.ParentId, readEvent.Depth)
} else {
log.Printf("No Event found")
}
*/
return
}
func initRoomTable() (err error) {
log.Printf("Init Room Table")
statement, err := DB.Prepare(`CREATE TABLE IF NOT EXISTS room (
id TEXT PRIMARY KEY,
version TEXT,
@ -249,61 +125,11 @@ func initRoomTable() (err error) {
return
}
statement.Exec()
/*
newRoom := &room.Room{Id: "test", Version: "test"}
err = CreateRoom(db, newRoom, "test")
if err != nil {
log.Printf("Error Create: %s", err)
return
}
err = CreateRoomMember(db, newRoom.Id, "test2")
if err != nil {
log.Printf("Error Create: %s", err)
return
}
roomMembers, err := ReadRoomMembers(db, newRoom.Id)
if err != nil {
log.Printf("Error Read Members: %s", err)
return
}
log.Println(roomMembers)
newRoom.Version = "test2"
err = UpdateRoom(db, newRoom)
if err != nil {
log.Printf("Error Update: %s", err)
return
}
err = DeleteRoomMember(db, newRoom.Id, "test")
if err != nil {
log.Printf("Error Delete: %s", err)
return
}
err = DeleteAllRoomMemberForUser(db, "test2")
if err != nil {
log.Printf("Error Delete: %s", err)
return
}
err = DeleteRoom(db, newRoom.Id)
if err != nil {
log.Printf("Error Delete: %s", err)
return
}
readRoom, err := ReadRoom(db, newRoom.Id)
if err != nil {
log.Printf("Error Read: %s", err)
return
}
if readRoom != nil {
log.Printf("Room ID: %s Version: %s Members: %s", readRoom.Id, readRoom.Version, readRoom.Members)
} else {
log.Printf("No Room found")
}
*/
return
}
func initTransactionTable() (err error) {
log.Printf("Init Transaction Table")
statement, err := DB.Prepare(`CREATE TABLE IF NOT EXISTS txn (
id TEXT PRIMARY KEY,
origin TEXT,
@ -314,40 +140,10 @@ func initTransactionTable() (err error) {
}
statement.Exec()
/*
newTransaction := &transaction.Transaction{Id: "test", Origin: "test.de", Timestamp: 1234}
err = CreateTransaction(db, newTransaction)
if err != nil {
log.Printf("Error Create: %s", err)
return
}
newTransaction.Origin = "test2.de"
err = UpdateTransaction(db, newTransaction)
if err != nil {
log.Printf("Error Update: %s", err)
return
}
err = DeleteTransaction(db, newTransaction.Id)
if err != nil {
log.Printf("Error Delete: %s", err)
return
}
readTransaction, err := ReadTransaction(db, newTransaction.Id)
if err != nil {
log.Printf("Error Read: %s", err)
return
}
if readTransaction != nil {
log.Printf("Transaction ID: %s Origin: %s Timestamp: %s PDUS: %s", readTransaction.Id, readTransaction.Origin, readTransaction.Timestamp, readTransaction.PDUS)
} else {
log.Printf("No Transaction found")
}
*/
return
}
func initUserTable() (err error) {
log.Printf("Init User Table")
statement, err := DB.Prepare(`CREATE TABLE IF NOT EXISTS user (
id TEXT PRIMARY KEY,
name TEXT,
@ -358,36 +154,6 @@ func initUserTable() (err error) {
}
statement.Exec()
/*
newUser := &user.User{Id: "test", Name: "test", Password: "test"}
err = CreateUser(db, newUser)
if err != nil {
log.Printf("Error Create: %s", err)
return
}
newUser.Name = "TEST2"
err = UpdateUser(db, newUser)
if err != nil {
log.Printf("Error Update: %s", err)
return
}
err = DeleteUser(db, newUser.Id)
if err != nil {
log.Printf("Error Delete: %s", err)
return
}
readUser, err := ReadUser(db, newUser.Id)
if err != nil {
log.Printf("Error Read: %s", err)
return
}
if readUser != nil {
log.Printf("User ID: %s Name: %s Password: %s Devices: %s", readUser.Id, readUser.Name, readUser.Password, readUser.Devices)
} else {
log.Printf("No User found")
}
*/
return
}

19
utils/encryptionService.go
View file

@ -49,17 +49,26 @@ func GenerateKeyPair() (publicKey ed25519.PublicKey, privateKey ed25519.PrivateK
return
}
func Sign(message []byte) []byte {
return ed25519.Sign(config.PrivateKey, message)
func Sign(message []byte) string {
signatureBytes := ed25519.Sign(config.PrivateKey, message)
return base64.RawStdEncoding.EncodeToString(signatureBytes)
}
func SignContent(content []byte) (signatures map[string]map[string]string) {
signatures = make(map[string]map[string]string)
signatures[config.Homeserver] = make(map[string]string)
signatures[config.Homeserver][config.KeyId] = string(Sign(content))
if !config.Signing {
return
}
signatures[config.Homeserver][config.KeyId] = Sign(content)
return
}
func VerifySignature(publicKey []byte, message []byte, signature []byte) bool {
return ed25519.Verify(publicKey, message, signature)
func VerifySignature(publicKey []byte, message []byte, signature string) bool {
signatureBytes, err := base64.RawStdEncoding.DecodeString(signature)
if err != nil {
return false
}
ed25519.Verify(config.PublicKey, message, signatureBytes)
return true
}

31
utils/requestChecker.go
View file

@ -1,9 +1,9 @@
package utils
import (
"bytes"
"encoding/json"
"fmt"
"log"
"net/http"
"strings"
@ -32,7 +32,10 @@ func CheckRequest(r *http.Request) (response *ErrorResponse) {
return
}
func CheckAuthHeader(r *http.Request) (response *ErrorResponse) {
func CheckAuthHeader(r *http.Request, content string) (response *ErrorResponse) {
if !config.AuthentificationCheck {
return
}
authHeader := r.Header.Get("Authorization")
if authHeader == "" || !strings.Contains(authHeader, "X-Matrix") {
response = &ErrorResponse{ErrorMessage: "Missing Authorization Header"}
@ -40,15 +43,12 @@ func CheckAuthHeader(r *http.Request) (response *ErrorResponse) {
}
keys := strings.Split(authHeader, ",")
origin := strings.Split(keys[0], "=")[1]
if !strings.Contains(keys[2], "ed25519") {
if !strings.Contains(keys[1], "ed25519") {
response = &ErrorResponse{ErrorMessage: "Missing ed25519 Signature Key"}
return
}
key := strings.Split(strings.Replace(strings.Split(keys[2], "=")[1], "\"", "", 2), ":")[1]
key := strings.Split(strings.Replace(strings.Split(keys[1], "=")[1], "\"", "", 2), ":")[1]
signature := strings.Replace(strings.Split(keys[2], "=")[1], "\"", "", 2)
buf := new(bytes.Buffer)
buf.ReadFrom(r.Body)
content := buf.String()
requestSummary := RequestSummary{
Method: r.Method,
Uri: r.RequestURI,
@ -61,7 +61,7 @@ func CheckAuthHeader(r *http.Request) (response *ErrorResponse) {
response = &ErrorResponse{ErrorMessage: "Error Creating Auth JSON String"}
return
}
correct := VerifySignature([]byte(key), requestSummaryString, []byte(signature))
correct := VerifySignature([]byte(key), requestSummaryString, signature)
if !correct {
response = &ErrorResponse{ErrorMessage: "Signature in Auth Header is incorrect"}
return
@ -81,7 +81,7 @@ func CreateAuthHeader(method string, uri string, destination string, content str
if err != nil {
return
}
authHeader = fmt.Sprintf("X-Matrix origin=%s,key=\"%s\",sig=\"%s\"", config.Homeserver, config.KeyId, Sign(SigningContent))
authHeader = fmt.Sprintf("X-Matrix origin=%s,key=%s,sig=%s", config.Homeserver, config.KeyId, Sign(SigningContent))
return
}
@ -98,6 +98,19 @@ func GetAccessToken(r *http.Request) (token string, response *ErrorResponse) {
return
}
func HandleHTTPError(res *http.Response) (response *ErrorResponse) {
log.Printf("Statuscode %s", res.Status)
response = &ErrorResponse{}
decoder := json.NewDecoder(res.Body)
err := decoder.Decode(response)
if err != nil {
log.Printf("Error not parseable")
return
}
log.Printf("%s (%s)", response.ErrorMessage, response.ErrorCode)
return
}
func IsJSONString(s string) bool {
var js string
return json.Unmarshal([]byte(s), &js) == nil