Feature/proposal token

CHANGELOG.md

@@ -2,6 +2,7 @@
 ## Feature
 - Add option to cancel own pending operations [#881](https://github.com/upb-uc4/ui-web/pull/881)
 - Add placeholder component for empty lists [#880](https://github.com/upb-uc4/ui-web/pull/880)
+- Add support for timed frontend signing tokens [#882](https://github.com/upb-uc4/ui-web/pull/882)
 
 ## Refactor
 - Improve performance by lazyloading [#835](https://github.com/upb-uc4/ui-web/pull/835)

src/api/api_models/common/SignedProposalMessage.ts

@@ -1,4 +1,4 @@
 export default interface SignedProposalMessage {
-    unsignedProposal: string;
+    unsignedProposalJwt: string;
     signature: string;
 }

src/api/api_models/common/SignedTransactionMessage.ts

@@ -1,4 +1,4 @@
 export default interface SignedTransactionMessage {
     signature: string;
-    unsignedTransaction: string;
+    unsignedTransactionJwt: string;
 }

src/api/api_models/common/UnsignedProposalMessage.ts

@@ -1,3 +1,3 @@
 export default interface UnsignedProposalMessage {
-    unsignedProposal: string;
+    unsignedProposalJwt: string;
 }

src/api/api_models/common/UnsignedTransactionMessage.ts

@@ -1,3 +1,3 @@
 export default interface UnsignedTransactionMessage {
-    unsignedTransaction: string;
+    unsignedTransactionJwt: string;
 }

src/api/contracts/AbstractTransaction.ts

@@ -52,12 +52,12 @@ export default abstract class AbstractTransaction {
         return new GenericResponseHandler("transaction").handleResponse(response);
     }
 
-    public decodeProposal(proposal: UnsignedProposalMessage, protoUrl?: string) {
-        return decodeProposal(proposal.unsignedProposal, protoUrl);
+    public decodeProposal(base64Proposal: string, protoUrl?: string) {
+        return decodeProposal(base64Proposal, protoUrl);
     }
 
-    public decodeTransaction(transaction: UnsignedTransactionMessage, protoUrl?: string) {
-        return decodeTransaction(transaction.unsignedTransaction, protoUrl);
+    public decodeTransaction(base64Transaction: string, protoUrl?: string) {
+        return decodeTransaction(base64Transaction, protoUrl);
     }
 
     public abstract buildTransactionInfo(...params: any): TransactionInfo;

src/api/contracts/ChaincodeUtility.ts

@@ -27,9 +27,12 @@ export default async function executeTransaction(executableTransaction: Abstract
 
     const unsignedProposal = await executableTransaction.getProposal();
 
-    if (!unsignedProposal.unsignedProposal) return false;
+    if (!unsignedProposal.unsignedProposalJwt) return false;
 
-    const proposal = await executableTransaction.decodeProposal(unsignedProposal, protoUrl).catch((reason: any) => {
+    const proposalTokenPayload = JSON.parse(atob(unsignedProposal.unsignedProposalJwt.split(".")[1]));
+    const unsignedProposalBytes = proposalTokenPayload["unsignedBytes"];
+
+    const proposal = await executableTransaction.decodeProposal(unsignedProposalBytes, protoUrl).catch((reason: any) => {
         useToast().error("Could not decode proposal. This is a bug on our side, please consider reporting this.");
     });
 
@@ -45,9 +48,9 @@ export default async function executeTransaction(executableTransaction: Abstract
         return false;
     }
 
-    const proposalSignature = await signProtobuf(unsignedProposal.unsignedProposal, privateKey);
+    const proposalSignature = await signProtobuf(unsignedProposalBytes, privateKey);
 
-    const proposalSignatureValidation = await verifyProtobufSignature(unsignedProposal.unsignedProposal, proposalSignature, publicKey);
+    const proposalSignatureValidation = await verifyProtobufSignature(unsignedProposalBytes, proposalSignature, publicKey);
 
     if (!proposalSignatureValidation) {
         useToast().error("Could not verify own signature. Your private key or certificate might be compromised.");
@@ -56,14 +59,17 @@ export default async function executeTransaction(executableTransaction: Abstract
 
     const signedProposalMessage: SignedProposalMessage = {
         signature: proposalSignature,
-        unsignedProposal: unsignedProposal.unsignedProposal,
+        unsignedProposalJwt: unsignedProposal.unsignedProposalJwt,
     };
 
     const unsignedTransaction = await executableTransaction.getTransaction(signedProposalMessage);
 
-    if (!unsignedTransaction.unsignedTransaction) return false;
+    if (!unsignedTransaction.unsignedTransactionJwt) return false;
+
+    const transactionTokenPayload = JSON.parse(atob(unsignedTransaction.unsignedTransactionJwt.split(".")[1]));
+    const unsignedTransactionBytes = transactionTokenPayload["unsignedBytes"];
 
-    const transaction = await executableTransaction.decodeTransaction(unsignedTransaction, protoUrl).catch((reason: any) => {
+    const transaction = await executableTransaction.decodeTransaction(unsignedTransactionBytes, protoUrl).catch((reason: any) => {
         useToast().error("Could not decode transaction. This is a bug on our side, please consider reporting this.");
     });
 
@@ -79,12 +85,8 @@ export default async function executeTransaction(executableTransaction: Abstract
         return false;
     }
 
-    const transactionSignature = await signProtobuf(unsignedTransaction.unsignedTransaction, privateKey);
-    const transactionSignatureValidation = await verifyProtobufSignature(
-        unsignedTransaction.unsignedTransaction,
-        transactionSignature,
-        publicKey
-    );
+    const transactionSignature = await signProtobuf(unsignedTransactionBytes, privateKey);
+    const transactionSignatureValidation = await verifyProtobufSignature(unsignedTransactionBytes, transactionSignature, publicKey);
 
     if (!transactionSignatureValidation) {
         useToast().error("Could not verify own signature. Your private key or certificate might be compromised.");
@@ -93,7 +95,7 @@ export default async function executeTransaction(executableTransaction: Abstract
 
     const signedTransactionMessage: SignedTransactionMessage = {
         signature: transactionSignature,
-        unsignedTransaction: unsignedTransaction.unsignedTransaction,
+        unsignedTransactionJwt: unsignedTransaction.unsignedTransactionJwt,
     };
 
     return await executableTransaction.submitTransaction(signedTransactionMessage);

src/use/helpers/ImmatriculationResponseHandler.ts

@@ -54,7 +54,7 @@ export class MatriculationValidationResponseHandler implements ResponseHandler<U
     }
 
     isUnsignedProposalMessage(object: any): object is UnsignedProposalMessage {
-        return (object as UnsignedProposalMessage).unsignedProposal !== undefined;
+        return (object as UnsignedProposalMessage).unsignedProposalJwt !== undefined;
     }
 
     handleResponse(response: APIResponse<UnsignedProposalMessage>): UnsignedProposalMessage {

tests/unit/api/operationManagement.spec.ts

@@ -537,11 +537,11 @@ describe("Operation Management tests", () => {
 
     test("Fetch certificate of enrollment", async () => {
         const reportManagement = new ReportManagement();
-        
+
         const response = await reportManagement.getCertificateOfEnrollment(student.authUser.username, "SS2020");
 
         expect(response.returnValue.size).toBeGreaterThan(0);
-    })
+    });
 
     afterAll(async () => {
         resetState(encryptionPassword);

tests/unit/transactionSigning.spec.ts

@@ -37,9 +37,10 @@ describe("Transaction Signing Tests", () => {
         if (!transaction) fail();
 
         expect(await new MockTransaction().validateTransaction(transaction)).toEqual(true);
-        transaction.data.actions[0].payload.action.endorsements[0].signature = "aHR0cHM6Ly93d3cueW91dHViZS5jb20vd2F0Y2g/dj1kUXc0dzlXZ1hjUQ==";
+        transaction.data.actions[0].payload.action.endorsements[0].signature =
+            "aHR0cHM6Ly93d3cueW91dHViZS5jb20vd2F0Y2g/dj1kUXc0dzlXZ1hjUQ==";
         expect(await new MockTransaction().validateTransaction(transaction)).toEqual(false);
-    })
+    });
 
     class MockTransaction extends AbstractTransaction {
         public getProposal(): Promise<UnsignedProposalMessage> {