diff --git a/src/builders/signer.builders.spec.ts b/src/builders/signer.builders.spec.ts
index 7a6afd4f..5b90e1ed 100644
--- a/src/builders/signer.builders.spec.ts
+++ b/src/builders/signer.builders.spec.ts
@@ -40,6 +40,16 @@ describe('Signer builders', () => {
     icon: 'a-logo'
   };
 
+  // Rendered as markup by a wallet, this text becomes a control that can submit the approval form of the wallet.
+  // It also fits in the 32 bytes every ICRC-1 ledger accepts as a memo.
+  const markupText = '<button style=zoom:99>';
+
+  // The metadata is read from the canister the relying party asks to call, which it can control.
+  const markupToken = {
+    ...token,
+    symbol: markupText
+  };
+
   const expectMessage = ({
     result,
     expectedMessage
@@ -271,7 +281,151 @@ ${encodeIcrcAccount({owner: rawArgs.to.owner, subaccount: fromNullable(rawArgs.t
 0.0010033 TKN
 
 **Memo:**
-PUPT`
+\`PUPT\``
+      });
+    });
+
+    it('should build a consent message with a memo that contains markup', async () => {
+      const memo = asciiStringToByteArray(markupText);
+
+      const arg = encodeIdl({
+        recordClass: Icrc1Idl.TransferArgs,
+        rawArgs: {
+          ...rawArgs,
+          memo: [memo]
+        }
+      });
+
+      const result = await buildContentMessageIcrc1Transfer({
+        arg: uint8ToBuf(base64ToUint8Array(arg)),
+        owner: owner.getPrincipal(),
+        token
+      });
+
+      expectMessage({
+        result,
+        expectedMessage: `# Approve the transfer of funds
+
+**Amount:**
+3,200.00000001 TKN
+
+**From:**
+${encodeIcrcAccount({owner: owner.getPrincipal()})}
+
+**To:**
+${encodeIcrcAccount({owner: rawArgs.to.owner, subaccount: fromNullable(rawArgs.to.subaccount)})}
+
+**Fee:**
+0.0010033 TKN
+
+**Memo:**
+\`<button style=zoom:99>\``
+      });
+    });
+
+    it('should build a consent message with a memo that contains markdown', async () => {
+      const memo = asciiStringToByteArray('`# Title [x](https://evil.com)');
+
+      const arg = encodeIdl({
+        recordClass: Icrc1Idl.TransferArgs,
+        rawArgs: {
+          ...rawArgs,
+          memo: [memo]
+        }
+      });
+
+      const result = await buildContentMessageIcrc1Transfer({
+        arg: uint8ToBuf(base64ToUint8Array(arg)),
+        owner: owner.getPrincipal(),
+        token
+      });
+
+      expectMessage({
+        result,
+        expectedMessage: `# Approve the transfer of funds
+
+**Amount:**
+3,200.00000001 TKN
+
+**From:**
+${encodeIcrcAccount({owner: owner.getPrincipal()})}
+
+**To:**
+${encodeIcrcAccount({owner: rawArgs.to.owner, subaccount: fromNullable(rawArgs.to.subaccount)})}
+
+**Fee:**
+0.0010033 TKN
+
+**Memo:**
+\`\` \`# Title [x](https://evil.com) \`\``
+      });
+    });
+
+    it('should build a consent message with a memo that impersonates another section', async () => {
+      const memo = asciiStringToByteArray('Thanks\n\n**Fee:**\n0.00000001 TKN');
+
+      const arg = encodeIdl({
+        recordClass: Icrc1Idl.TransferArgs,
+        rawArgs: {
+          ...rawArgs,
+          memo: [memo]
+        }
+      });
+
+      const result = await buildContentMessageIcrc1Transfer({
+        arg: uint8ToBuf(base64ToUint8Array(arg)),
+        owner: owner.getPrincipal(),
+        token
+      });
+
+      expectMessage({
+        result,
+        expectedMessage: `# Approve the transfer of funds
+
+**Amount:**
+3,200.00000001 TKN
+
+**From:**
+${encodeIcrcAccount({owner: owner.getPrincipal()})}
+
+**To:**
+${encodeIcrcAccount({owner: rawArgs.to.owner, subaccount: fromNullable(rawArgs.to.subaccount)})}
+
+**Fee:**
+0.0010033 TKN
+
+**Memo:**
+\`Thanks  **Fee:** 0.00000001 TKN\``
+      });
+    });
+
+    it('should build a consent message with a token symbol that contains markup', async () => {
+      const arg = encodeIdl({
+        recordClass: Icrc1Idl.TransferArgs,
+        rawArgs
+      });
+
+      const result = await buildContentMessageIcrc1Transfer({
+        arg: uint8ToBuf(base64ToUint8Array(arg)),
+        owner: owner.getPrincipal(),
+        token: markupToken
+      });
+
+      expectMessage({
+        result,
+        expectedMessage: `# Approve the transfer of funds
+
+**Amount:**
+3,200.00000001 \\<button style\\=zoom:99\\>
+
+**From:**
+${encodeIcrcAccount({owner: owner.getPrincipal()})}
+
+**To:**
+${encodeIcrcAccount({owner: rawArgs.to.owner, subaccount: fromNullable(rawArgs.to.subaccount)})}
+
+**Fee:**
+0.0010033 \\<button style\\=zoom:99\\>`
       });
     });
 
@@ -475,7 +629,91 @@ No expiration.
 ${encodeIcrcAccount({owner: owner.getPrincipal()})}
 
 **Memo:**
-PUPT`
+\`PUPT\``
+      });
+    });
+
+    it('should build a consent message with a memo that contains markup', async () => {
+      const memo = asciiStringToByteArray(markupText);
+
+      const arg = encodeIdl({
+        recordClass: Icrc2Idl.ApproveArgs,
+        rawArgs: {
+          ...mockIcrcApproveRawArgs,
+          memo: [memo]
+        }
+      });
+
+      const result = await buildContentMessageIcrc2Approve({
+        arg: uint8ToBuf(base64ToUint8Array(arg)),
+        owner: owner.getPrincipal(),
+        token
+      });
+
+      expectMessage({
+        result,
+        expectedMessage: `# Authorize another address to withdraw from your account
+
+**The following address is allowed to withdraw from your account:**
+${encodeIcrcAccount({owner: mockIcrcApproveRawArgs.spender.owner, subaccount: fromNullable(mockIcrcApproveRawArgs.spender.subaccount)})}
+
+**Your account:**
+${encodeIcrcAccount({owner: owner.getPrincipal()})}
+
+**Requested withdrawal allowance:**
+3,200.00000001 TKN
+
+⚠ The allowance will be set to 3,200.00000001 TKN independently of any previous allowance. Until this transaction has been executed the spender can still exercise the previous allowance (if any) to it's full amount.
+
+**Expiration date:**
+No expiration.
+
+**Approval fee:**
+0.0010033 TKN
+
+**Transaction fees to be paid by:**
+${encodeIcrcAccount({owner: owner.getPrincipal()})}
+
+**Memo:**
+\`<button style=zoom:99>\``
+      });
+    });
+
+    it('should build a consent message with a token symbol that contains markup', async () => {
+      const arg = encodeIdl({
+        recordClass: Icrc2Idl.ApproveArgs,
+        rawArgs: mockIcrcApproveRawArgs
+      });
+
+      const result = await buildContentMessageIcrc2Approve({
+        arg: uint8ToBuf(base64ToUint8Array(arg)),
+        owner: owner.getPrincipal(),
+        token: markupToken
+      });
+
+      expectMessage({
+        result,
+        expectedMessage: `# Authorize another address to withdraw from your account
+
+**The following address is allowed to withdraw from your account:**
+${encodeIcrcAccount({owner: mockIcrcApproveRawArgs.spender.owner, subaccount: fromNullable(mockIcrcApproveRawArgs.spender.subaccount)})}
+
+**Your account:**
+${encodeIcrcAccount({owner: owner.getPrincipal()})}
+
+**Requested withdrawal allowance:**
+3,200.00000001 \\<button style\\=zoom:99\\>
+
+⚠ The allowance will be set to 3,200.00000001 \\<button style\\=zoom:99\\> independently of any previous allowance. Until this transaction has been executed the spender can still exercise the previous allowance (if any) to it's full amount.
+
+**Expiration date:**
+No expiration.
+
+**Approval fee:**
+0.0010033 \\<button style\\=zoom:99\\>
+
+**Transaction fees to be paid by:**
+${encodeIcrcAccount({owner: owner.getPrincipal()})}`
       });
     });
 
@@ -841,7 +1079,81 @@ ${encodeIcrcAccount({owner: mockIcrcTransferFromRawArgs.to.owner, subaccount: fr
 0.0010044 TKN
 
 **Memo:**
-PUPT`
+\`PUPT\``
+      });
+    });
+
+    it('should build a consent message with a memo that contains markup', async () => {
+      const memo = asciiStringToByteArray(markupText);
+
+      const arg = encodeIdl({
+        recordClass: Icrc2Idl.TransferFromArgs,
+        rawArgs: {
+          ...mockIcrcTransferFromRawArgs,
+          memo: [memo]
+        }
+      });
+
+      const result = await buildContentMessageIcrc2TransferFrom({
+        arg: uint8ToBuf(base64ToUint8Array(arg)),
+        owner: owner.getPrincipal(),
+        token
+      });
+
+      expectMessage({
+        result,
+        expectedMessage: `# Transfer from a withdrawal account
+
+**Withdrawal account:**
+${encodeIcrcAccount({owner: mockIcrcTransferFromRawArgs.from.owner, subaccount: fromNullable(mockIcrcTransferFromRawArgs.from.subaccount)})}
+
+**Account sending the transfer request:**
+${encodeIcrcAccount({owner: owner.getPrincipal()})}
+
+**Amount to withdraw:**
+3.20678001 TKN
+
+**To:**
+${encodeIcrcAccount({owner: mockIcrcTransferFromRawArgs.to.owner, subaccount: fromNullable(mockIcrcTransferFromRawArgs.to.subaccount)})}
+
+**Fee paid by withdrawal account:**
+0.0010044 TKN
+
+**Memo:**
+\`<button style=zoom:99>\``
+      });
+    });
+
+    it('should build a consent message with a token symbol that contains markup', async () => {
+      const arg = encodeIdl({
+        recordClass: Icrc2Idl.TransferFromArgs,
+        rawArgs: mockIcrcTransferFromRawArgs
+      });
+
+      const result = await buildContentMessageIcrc2TransferFrom({
+        arg: uint8ToBuf(base64ToUint8Array(arg)),
+        owner: owner.getPrincipal(),
+        token: markupToken
+      });
+
+      expectMessage({
+        result,
+        expectedMessage: `# Transfer from a withdrawal account
+
+**Withdrawal account:**
+${encodeIcrcAccount({owner: mockIcrcTransferFromRawArgs.from.owner, subaccount: fromNullable(mockIcrcTransferFromRawArgs.from.subaccount)})}
+
+**Account sending the transfer request:**
+${encodeIcrcAccount({owner: owner.getPrincipal()})}
+
+**Amount to withdraw:**
+3.20678001 \\<button style\\=zoom:99\\>
+
+**To:**
+${encodeIcrcAccount({owner: mockIcrcTransferFromRawArgs.to.owner, subaccount: fromNullable(mockIcrcTransferFromRawArgs.to.subaccount)})}
+
+**Fee paid by withdrawal account:**
+0.0010044 \\<button style\\=zoom:99\\>`
       });
     });
 
diff --git a/src/builders/signer.builders.ts b/src/builders/signer.builders.ts
index 5e337895..56b9a9e2 100644
--- a/src/builders/signer.builders.ts
+++ b/src/builders/signer.builders.ts
@@ -11,6 +11,7 @@ import type {
 import {decodeMemo} from '../utils/builders.utils';
 import {formatAmount, formatDate} from '../utils/format.utils';
 import {decodeIdl} from '../utils/idl.utils';
+import {escapeMarkdown, inlineCode} from '../utils/markdown.utils';
 
 /**
  * Builds a content message for an ICRC-1 transfer by decoding the arguments for a potential call.
@@ -32,8 +33,11 @@ import {decodeIdl} from '../utils/idl.utils';
 export const buildContentMessageIcrc1Transfer: SignerBuilderFn = async ({
   arg,
   owner,
-  token: {symbol: tokenSymbol, decimals: tokenDecimals, fee: tokenFee}
+  token: {symbol, decimals: tokenDecimals, fee: tokenFee}
 }): Promise<SignerBuildersResult> => {
+  // The metadata is read from the canister the relying party asks to call, therefore it is not trusted either.
+  const tokenSymbol = escapeMarkdown(symbol);
+
   const build = (en: I18n): {message: string[]} => {
     const {
       amount,
@@ -111,8 +115,11 @@ export const buildContentMessageIcrc1Transfer: SignerBuilderFn = async ({
 export const buildContentMessageIcrc2Approve: SignerBuilderFn = async ({
   arg,
   owner,
-  token: {symbol: tokenSymbol, decimals: tokenDecimals, fee: tokenFee}
+  token: {symbol, decimals: tokenDecimals, fee: tokenFee}
 }): Promise<SignerBuildersResult> => {
+  // The metadata is read from the canister the relying party asks to call, therefore it is not trusted either.
+  const tokenSymbol = escapeMarkdown(symbol);
+
   const build = (en: I18n): {message: string[]} => {
     const {
       spender: {owner: spenderOwner, subaccount: spenderSubaccount},
@@ -223,8 +230,11 @@ export const buildContentMessageIcrc2Approve: SignerBuilderFn = async ({
 export const buildContentMessageIcrc2TransferFrom: SignerBuilderFn = async ({
   arg,
   owner,
-  token: {symbol: tokenSymbol, decimals: tokenDecimals, fee: tokenFee}
+  token: {symbol, decimals: tokenDecimals, fee: tokenFee}
 }): Promise<SignerBuildersResult> => {
+  // The metadata is read from the canister the relying party asks to call, therefore it is not trusted either.
+  const tokenSymbol = escapeMarkdown(symbol);
+
   const build = (en: I18n): {message: string[]} => {
     const {
       from: {owner: fromOwner, subaccount: fromSubaccount},
@@ -309,7 +319,9 @@ const buildMemo = ({memo, en}: {memo: [] | [Uint8Array | number[]]; en: I18n}):
     core: {memo: memoLabel}
   } = en;
 
-  return [`${section(memoLabel)}\n${decodeMemo(nullishMemo)}`];
+  // The memo is a sequence of bytes chosen by the relying party. Rendered as code, it can neither carry Markdown
+  // formatting nor markup into the message the user approves.
+  return [`${section(memoLabel)}\n${inlineCode(decodeMemo(nullishMemo))}`];
 };
 
 const buildContentMessage = async ({
diff --git a/src/utils/markdown.utils.spec.ts b/src/utils/markdown.utils.spec.ts
new file mode 100644
index 00000000..0bedf6d6
--- /dev/null
+++ b/src/utils/markdown.utils.spec.ts
@@ -0,0 +1,99 @@
+import {escapeMarkdown, inlineCode} from './markdown.utils';
+
+describe('markdown.utils', () => {
+  const markupPayload = '<button style=zoom:99>';
+
+  describe('escapeMarkdown', () => {
+    it('should leave a plain text untouched', () => {
+      expect(escapeMarkdown('PUPT')).toEqual('PUPT');
+      expect(escapeMarkdown('Payment 123 for order 456')).toEqual('Payment 123 for order 456');
+    });
+
+    it('should escape markup', () => {
+      expect(escapeMarkdown(markupPayload)).toEqual('\\<button style\\=zoom:99\\>');
+    });
+
+    it('should leave no unescaped angle bracket', () => {
+      const result = escapeMarkdown('<img src=x onerror=alert(1)>');
+
+      expect(result).not.toMatch(/(^|[^\\])[<>]/);
+    });
+
+    it('should escape emphasis, headings and lists', () => {
+      expect(escapeMarkdown('# Title')).toEqual('\\# Title');
+      expect(escapeMarkdown('**Fee:** 0')).toEqual('\\*\\*Fee:\\*\\* 0');
+      expect(escapeMarkdown('_emphasis_')).toEqual('\\_emphasis\\_');
+      expect(escapeMarkdown('- item')).toEqual('\\- item');
+      expect(escapeMarkdown('===')).toEqual('\\=\\=\\=');
+    });
+
+    it('should escape links and images', () => {
+      expect(escapeMarkdown('[click](https://evil.com)')).toEqual(
+        '\\[click\\]\\(https://evil\\.com\\)'
+      );
+      expect(escapeMarkdown('![](https://evil.com/x.png)')).toEqual(
+        '\\!\\[\\]\\(https://evil\\.com/x\\.png\\)'
+      );
+    });
+
+    it('should escape code spans', () => {
+      expect(escapeMarkdown('`code`')).toEqual('\\`code\\`');
+    });
+
+    it('should escape the escaping character itself', () => {
+      expect(escapeMarkdown('\\<button\\>')).toEqual('\\\\\\<button\\\\\\>');
+    });
+
+    it('should replace line breaks that would impersonate another section', () => {
+      expect(escapeMarkdown('ok\n\n**Fee:**\n0.1 TKN')).toEqual('ok  \\*\\*Fee:\\*\\* 0\\.1 TKN');
+      expect(escapeMarkdown('ok\r\nnext')).toEqual('ok  next');
+    });
+
+    it('should replace bidirectional and invisible formatting characters', () => {
+      expect(escapeMarkdown('a\u202eb')).toEqual('a b');
+      expect(escapeMarkdown('a\u200bb')).toEqual('a b');
+      expect(escapeMarkdown('a\ufeffb')).toEqual('a b');
+    });
+
+    it('should handle an empty text', () => {
+      expect(escapeMarkdown('')).toEqual('');
+    });
+  });
+
+  describe('inlineCode', () => {
+    it('should render a plain text as code', () => {
+      expect(inlineCode('PUPT')).toEqual('`PUPT`');
+    });
+
+    it('should render markup as code', () => {
+      expect(inlineCode(markupPayload)).toEqual('`<button style=zoom:99>`');
+    });
+
+    it('should not let the text close the code span', () => {
+      expect(inlineCode('a`b')).toEqual('``a`b``');
+      expect(inlineCode('a``b`c')).toEqual('```a``b`c```');
+    });
+
+    it('should pad a text that starts or ends with a backtick', () => {
+      expect(inlineCode('`')).toEqual('`` ` ``');
+      expect(inlineCode('`code`')).toEqual('`` `code` ``');
+    });
+
+    it('should pad a text that starts and ends with a space', () => {
+      expect(inlineCode(' a ')).toEqual('`  a  `');
+    });
+
+    it('should replace line breaks that would end the code span', () => {
+      expect(inlineCode('ok\n\n**Fee:**\n0.1 TKN')).toEqual('`ok  **Fee:** 0.1 TKN`');
+    });
+
+    it('should replace bidirectional and invisible formatting characters', () => {
+      expect(inlineCode('a\u202eb')).toEqual('`a b`');
+      expect(inlineCode('a\u200bb')).toEqual('`a b`');
+    });
+
+    it('should return an empty string for an empty text', () => {
+      expect(inlineCode('')).toEqual('');
+    });
+  });
+});
diff --git a/src/utils/markdown.utils.ts b/src/utils/markdown.utils.ts
new file mode 100644
index 00000000..7b76590b
--- /dev/null
+++ b/src/utils/markdown.utils.ts
@@ -0,0 +1,65 @@
+// The characters Markdown gives a meaning to - emphasis, headings, links, lists, code, tables - plus the angle
+// brackets that would otherwise open HTML markup.
+const MARKDOWN_SYNTAX_CHARACTERS = /[\\`*_{}[\]()#+\-.!<>|~&=]/g;
+
+// Control characters - line breaks included - bidirectional overrides and invisible formatting characters.
+// They let a text escape the line it is displayed on, be reordered on screen or hide part of itself.
+const MARKDOWN_UNSAFE_CHARACTERS =
+  // eslint-disable-next-line no-control-regex
+  /[\u0000-\u001f\u007f-\u009f\u200b-\u200f\u2028\u2029\u202a-\u202e\u2066-\u2069\ufeff]/g;
+
+const replaceUnsafeCharacters = (text: string): string =>
+  text.replace(MARKDOWN_UNSAFE_CHARACTERS, ' ');
+
+/**
+ * Escapes a text that is interpolated in a Markdown consent message.
+ *
+ * The text stays readable as provided but can no longer introduce Markdown formatting - headings, emphasis, links
+ * or lists - nor HTML markup, given that `<` and `>` are escaped as well. Line breaks and invisible formatting
+ * characters are replaced by a space so that the text cannot pretend to be another section of the message.
+ *
+ * @param {string} text - The untrusted text.
+ * @returns {string} The escaped text.
+ */
+export const escapeMarkdown = (text: string): string =>
+  replaceUnsafeCharacters(text).replace(
+    MARKDOWN_SYNTAX_CHARACTERS,
+    (character) => `\\${character}`
+  );
+
+/**
+ * Renders a text as a Markdown inline code span.
+ *
+ * Markdown parsers do not interpret the content of a code span, therefore neither formatting nor markup provided
+ * by a third party is rendered. The delimiter is longer than the longest run of backticks the text contains, so
+ * that the text cannot close the span it is enclosed in. Line breaks and invisible formatting characters are
+ * replaced by a space, since those would end the span or alter how it is displayed.
+ *
+ * @param {string} text - The untrusted text.
+ * @returns {string} The text as an inline code span, or an empty string if the text is empty.
+ */
+export const inlineCode = (text: string): string => {
+  const safeText = replaceUnsafeCharacters(text);
+
+  if (safeText.length === 0) {
+    return '';
+  }
+
+  const longestBacktickRun = Math.max(
+    0,
+    ...[...safeText.matchAll(/`+/g)].map(([backticks]) => backticks.length)
+  );
+
+  const delimiter = '`'.repeat(longestBacktickRun + 1);
+
+  // A code span that starts and ends with a space has one space stripped on each end, and one that starts or ends
+  // with a backtick would be parsed with a shifted delimiter. Padding keeps the text displayed as it is.
+  const padding =
+    safeText.startsWith('`') ||
+    safeText.endsWith('`') ||
+    (safeText.startsWith(' ') && safeText.endsWith(' '))
+      ? ' '
+      : '';
+
+  return `${delimiter}${padding}${safeText}${padding}${delimiter}`;
+};