mirror of
https://github.com/matrix-org/dendrite
synced 2024-12-24 12:03:29 +00:00
2cb7c91c5d
* Store our own keys in the keydb The DirectKeyFetcher makes the assumption that you can always reach the key/v2/server endpoint of any server, including our own. We previously haven't bothered to store our own keys in the keydb so this would mean we end up making key requests to ourselves. In the libp2p world as an example, self-dialling is not possible, therefore this would render it impossible to get our own keys. This commit adds our own keys into the keydb so that we don't create unnecessarily (and maybe impossible) requests. * Use golang.org/x/crypto/ed25519 instead of crypto/ed25519 for pre-Go 1.13
113 lines
3.5 KiB
Go
113 lines
3.5 KiB
Go
// Copyright 2017-2018 New Vector Ltd
|
|
// Copyright 2019-2020 The Matrix.org Foundation C.I.C.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package postgres
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"math"
|
|
|
|
"golang.org/x/crypto/ed25519"
|
|
|
|
"github.com/matrix-org/gomatrixserverlib"
|
|
)
|
|
|
|
// A Database implements gomatrixserverlib.KeyDatabase and is used to store
|
|
// the public keys for other matrix servers.
|
|
type Database struct {
|
|
statements serverKeyStatements
|
|
}
|
|
|
|
// NewDatabase prepares a new key database.
|
|
// It creates the necessary tables if they don't already exist.
|
|
// It prepares all the SQL statements that it will use.
|
|
// Returns an error if there was a problem talking to the database.
|
|
func NewDatabase(
|
|
dataSourceName string,
|
|
serverName gomatrixserverlib.ServerName,
|
|
serverKey ed25519.PublicKey,
|
|
serverKeyID gomatrixserverlib.KeyID,
|
|
) (*Database, error) {
|
|
db, err := sql.Open("postgres", dataSourceName)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
d := &Database{}
|
|
err = d.statements.prepare(db)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
// Store our own keys so that we don't end up making HTTP requests to find our
|
|
// own keys
|
|
index := gomatrixserverlib.PublicKeyLookupRequest{
|
|
ServerName: serverName,
|
|
KeyID: serverKeyID,
|
|
}
|
|
value := gomatrixserverlib.PublicKeyLookupResult{
|
|
VerifyKey: gomatrixserverlib.VerifyKey{
|
|
Key: gomatrixserverlib.Base64String(serverKey),
|
|
},
|
|
ValidUntilTS: math.MaxUint64 >> 1,
|
|
ExpiredTS: gomatrixserverlib.PublicKeyNotExpired,
|
|
}
|
|
err = d.StoreKeys(
|
|
context.Background(),
|
|
map[gomatrixserverlib.PublicKeyLookupRequest]gomatrixserverlib.PublicKeyLookupResult{
|
|
index: value,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return d, nil
|
|
}
|
|
|
|
// FetcherName implements KeyFetcher
|
|
func (d Database) FetcherName() string {
|
|
return "KeyDatabase"
|
|
}
|
|
|
|
// FetchKeys implements gomatrixserverlib.KeyDatabase
|
|
func (d *Database) FetchKeys(
|
|
ctx context.Context,
|
|
requests map[gomatrixserverlib.PublicKeyLookupRequest]gomatrixserverlib.Timestamp,
|
|
) (map[gomatrixserverlib.PublicKeyLookupRequest]gomatrixserverlib.PublicKeyLookupResult, error) {
|
|
return d.statements.bulkSelectServerKeys(ctx, requests)
|
|
}
|
|
|
|
// StoreKeys implements gomatrixserverlib.KeyDatabase
|
|
func (d *Database) StoreKeys(
|
|
ctx context.Context,
|
|
keyMap map[gomatrixserverlib.PublicKeyLookupRequest]gomatrixserverlib.PublicKeyLookupResult,
|
|
) error {
|
|
// TODO: Inserting all the keys within a single transaction may
|
|
// be more efficient since the transaction overhead can be quite
|
|
// high for a single insert statement.
|
|
var lastErr error
|
|
for request, keys := range keyMap {
|
|
if err := d.statements.upsertServerKeys(ctx, request, keys); err != nil {
|
|
// Rather than returning immediately on error we try to insert the
|
|
// remaining keys.
|
|
// Since we are inserting the keys outside of a transaction it is
|
|
// possible for some of the inserts to succeed even though some
|
|
// of the inserts have failed.
|
|
// Ensuring that we always insert all the keys we can means that
|
|
// this behaviour won't depend on the iteration order of the map.
|
|
lastErr = err
|
|
}
|
|
}
|
|
return lastErr
|
|
}
|