Evaluate Web of Trust in Automatic Access Grant

[chenkins]

Story

• Persona:
• Need: Evaluate Web of Trust in Automatic Access Grant
• Purpose:

Acceptance Criteria

• evaluate WoT in Katta Client

Open Questions

Context

Implementation

[chenkins]

relates to cryptomator/hub#281

[chenkins]

@overheadhunter could you point me to the ts snippet that we need to implement for automatic access grant?

[overheadhunter]

Use the typescript implementation as a reference:

1. From the perspective of the currently logged-in user, GET a list of trusted users from /api/users/trusted:

katta-server/frontend/src/common/backend.ts

Lines 272 to 274 in 06c4d28

	public async listTrusted(): Promise<TrustDto[]> {
	return axiosAuth.get<TrustDto[]>('/users/trusted').then(response => response.data);
	}

katta-server/frontend/src/common/backend.ts

Lines 94 to 97 in 06c4d28

	export type TrustDto = {
	trustedUserId: string,
	signatureChain: string[]
	}

2. Verify all returned signature chains! For each signature chain, the first element of each chain is signed by the current user, i.e. the signature can be verified using their public key. Each further element is signed by the respective user. The last element must be the key to be verified.

katta-server/frontend/src/common/wot.ts

Lines 55 to 76 in 06c4d28

	/**
	* Recursively verifies a chain of signatures, where each signature signs the public key of the next signature.
	* @param signatureChain The chain of signatures to verify
	* @param signerPublicKey A trusted public key to verify the first signature in the chain
	* @param allegedSignedKey The public key that should be signed by the last signature in the chain
	* @throws Error if the signature chain is invalid
	*/
	async function verifyRescursive(signatureChain: string[], signerPublicKey: CryptoKey, allegedSignedKey: SignedKeys) {
	// get first element of signature chain:
	const [signature, ...remainingChain] = signatureChain;
	const [, signedKeys] = await JWT.parse(signature, signerPublicKey) as [JWTHeader, SignedKeys];
	if (remainingChain.length === 0) {
	// last element in chain should match signed public key
	if (!deeplyEqual(signedKeys, allegedSignedKey)) {
	throw new Error('Alleged public key does not match signed public key');
	}
	} else {
	// otherwise, the payload is an intermediate public key used to sign the next element
	const nextTrustedPublicKey = await asPublicKey(base64.parse(signedKeys.ecdsaPublicKey), UserKeys.ECDSA_KEY_DESIGNATION, UserKeys.ECDSA_PUB_KEY_USAGES);
	await verifyRescursive(remainingChain, nextTrustedPublicKey, allegedSignedKey);
	}
	}

3. For users, who are considered trustworthy (i.e. the signature chain between the current user and the to-be-trusted user is shorter than a configurable threshold), use the verified ECDH public key to encrypt the vault's member key (and optionally its recovery key):

katta-server/frontend/src/common/universalVaultFormat.ts

Lines 521 to 529 in 24f4993

	/** @inheritdoc */
	public async encryptForUser(userPublicKey: CryptoKey | Uint8Array, isOwner?: boolean): Promise<string> {
	const payload: UvfAccessTokenPayload = {
	key: await this.memberKey.serializeKey(),
	recoveryKey: isOwner && this.recoveryKey.privateKey ? await this.recoveryKey.serializePrivateKey() : undefined
	};
	return OtherVaultMember.withPublicKey(userPublicKey).createAccessToken(payload);
	}
	}

katta-server/frontend/src/common/crypto.ts

Lines 64 to 91 in 24f4993

	/**
	* Represents a vault member by their public key.
	*/
	export class OtherVaultMember {
	protected constructor(readonly publicKey: Promise<CryptoKey>) { }
	/**
	* Creates a new vault member with the given public key
	* @param publicKey The public key of the vault member
	* @returns A vault member with the given public key
	*/
	public static withPublicKey(publicKey: CryptoKey | BufferSource): OtherVaultMember {
	const keyPromise = asPublicKey(publicKey, UserKeys.ECDH_KEY_DESIGNATION);
	return new OtherVaultMember(keyPromise);
	}
	/**
	* Creates an access token for this vault member.
	* @param payload The payload to encrypt
	* @return A ECDH-ES encrypted JWE containing the encrypted payload
	*/
	public async createAccessToken(payload: AccessTokenPayload): Promise<string> {
	const jwe = await JWE.build(payload).encrypt(Recipient.ecdhEs('org.cryptomator.hub.userkey', await this.publicKey));
	return jwe.compactSerialization();
	}
	}

4. Collect these JWEs and bulk-upload them to the server. (POST /vaults/${vaultId}/access-tokens, {"user1": "jwe1", "user2": "jwe2", ...)