{
 "schemaVersion": 1,
 "pathSlug": "wire-protocols",
 "items": [
  {
   "questionId": "crypto_basics.encoding_vs_encryption__471028",
   "topic": "crypto_basics",
   "subSkill": "encoding_vs_encryption",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A teammate says the JWT in localStorage is 'encrypted because it looks like random characters'. What is the actual transformation applied to a standard signed JWT payload?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "AES-GCM symmetric ciphertext requiring the server's signing key"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "ChaCha20 stream cipher output keyed from the JWT issuer secret"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Base64url encoding of JSON, readable by anyone with the token"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "RSA-OAEP wrapping with the issuer's public key for confidentiality"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.encoding_vs_encryption__51067",
   "topic": "crypto_basics",
   "subSkill": "encoding_vs_encryption",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "An engineering org keeps shipping the encoding-vs-encryption mistake despite training. Which intervention pattern actually shifts the failure rate - and which is the well-meaning placebo?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Mandate that all sensitive data flow through a central security team review before any production deployment proceeds."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Run an annual security awareness e-learning module and track completion percentages on the corporate compliance dashboard."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Adopt a single approved cryptography library; the security team then forces engineers to call the safer primitive at every code site."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Embed primitive-naming hygiene in code review and static rules; the design doc must declare the key and its custodian."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.encoding_vs_encryption__51050",
   "topic": "crypto_basics",
   "subSkill": "encoding_vs_encryption",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A vendor pitches 'we obfuscate the payload before it leaves the SDK'. What is the precise gap between that claim and an actual cryptographic guarantee?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Obfuscation is a weak symmetric cipher whose key is embedded in the SDK binary and rotated each release cycle."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Obfuscation operates above the transport layer, so it composes with TLS to deliver an additional layer of secrecy."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Obfuscation has no key and no security argument; a motivated reverser recovers the input with modest effort."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Obfuscation applies a one-way digest; the SDK binary cannot restore the input that an attacker wants."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.encoding_vs_encryption__250814",
   "topic": "crypto_basics",
   "subSkill": "encoding_vs_encryption",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What confidentiality do CBOR and MessagePack provide for the bytes they carry?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "They are keyed encodings where the schema id acts as a shared secret between sender and receiver of the payload."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "They are binary serialisations; any reader can parse them back to the original objects with no secret involved."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "They are obfuscated representations whose typed framing prevents passive observers from reconstructing the values."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "They are integrity-protected wire formats by default; a parser refuses to decode without an authenticator tag."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.encoding_vs_encryption__500672",
   "topic": "crypto_basics",
   "subSkill": "encoding_vs_encryption",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What does this Python snippet print?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "from cryptography.hazmat.primitives.ciphers.aead import AESGCM\nkey = b'\\x00'*32; nonce = b'\\x00'*12\naes = AESGCM(key)\nc1 = aes.encrypt(nonce, b'hello', None)\nc2 = aes.encrypt(nonce, b'hello', None)\nprint('same' if c1 == c2 else 'diff')",
    "label": "encoding-vs-encryption.ts"
   },
   "widget": {
    "kind": "predict_output",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Error: InvalidTag"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "same"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Error: NonceReuse"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "diff"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.encoding_vs_encryption__51045",
   "topic": "crypto_basics",
   "subSkill": "encoding_vs_encryption",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A team uses Protocol Buffers on the wire and notes that the bytes 'look opaque to a human'. What does that opacity mean for the confidentiality of the payload?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It means the schema id at the head functions as a shared secret that locks decoding to consenting endpoints only."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Nothing; protobuf is a serialization, and any reader with the .proto definition decodes the message back to fields."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It means the binary framing varies per message; identical payloads produce distinct byte sequences over time."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It means a passive observer must guess the field numbers, raising the work factor above a casual extraction attack."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.encoding_vs_encryption__300453",
   "topic": "crypto_basics",
   "subSkill": "encoding_vs_encryption",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What does this Python snippet print?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "import base64\nb = b'hello world'\nprint(len(base64.b64encode(b)))",
    "label": "encoding-vs-encryption.ts"
   },
   "widget": {
    "kind": "predict_output",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "16"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "11"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "32"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "24"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.encoding_vs_encryption__51056",
   "topic": "crypto_basics",
   "subSkill": "encoding_vs_encryption",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A review comment calls a PEM file holding a private key 'safe the way it sits on disk'. Why does that claim not hold?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "PEM wraps the underlying key with a header-derived passphrase that locks it against bystanders reading the file."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "PEM stores keys with a fixed-length padding scheme that hardens them against truncation attacks during transport."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "PEM canonicalises the key bytes under a tag that detects single-bit corruption during storage and replication runs."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "PEM is Base64 framing for DER bytes; its security comes from key handling, not from the encoding around the bytes."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.encoding_vs_encryption__51053",
   "topic": "crypto_basics",
   "subSkill": "encoding_vs_encryption",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A PCI auditor asks why the team picked tokenization over column-level encryption for the card-number store. Which architectural distinction supports that choice?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Tokens have no mathematical relationship to the PAN; recovery requires the vault, so leaks cannot be inverted."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Tokens are produced deterministically from the PAN; the database can index them under the normal sort comparator."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Tokens are produced by a faster cipher than AES, so the operation cost on every read path drops by a large factor."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Tokens preserve the input length without a key, which keeps the storage column type stable under PCI's row schema."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.encoding_vs_encryption__300452",
   "topic": "crypto_basics",
   "subSkill": "encoding_vs_encryption",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What does this Node.js snippet print?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "const { createHash } = require('crypto');\nconst h = createHash('sha256').update('hello').digest();\nconsole.log(h.length);",
    "label": "encoding-vs-encryption.ts"
   },
   "widget": {
    "kind": "predict_output",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "44"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "32"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "16"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "64"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.tcp_udp__65582",
   "topic": "networking",
   "subSkill": "tcp_udp",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the difference between flow control and congestion control in TCP?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Flow control applies only to UDP datagrams, while congestion control applies only to TCP segments"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Flow control reacts to ACKs from the receiver, while congestion control reacts to NAKs from routers"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "They are two names for one window: rwnd and cwnd are computed from the same loss signal"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Flow control protects the receiver's buffer via rwnd; congestion control protects the network via cwnd"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "networking.tcp_udp__65644",
   "topic": "networking",
   "subSkill": "tcp_udp",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What protocol does VoIP typically use?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "TCP, carried by TLS"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "QUIC over TLS 1.3"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "UDP, carried by RTP"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "SCTP by way of DTLS"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.tcp_udp__19634",
   "topic": "networking",
   "subSkill": "tcp_udp",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "In TCP streams, what does head-of-line blocking refer to?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Later bytes stalled by missing earlier bytes"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Out-of-order delivery of bytes to the receiving application above the socket"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Sender pacing of segments based on the round-trip time and congestion window"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Receiver coalescing of cumulative acknowledgements into a single ACK segment"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.tcp_udp__65235",
   "topic": "networking",
   "subSkill": "tcp_udp",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the key difference between SCTP and TCP?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "SCTP supports multiple independent streams within a single connection and multi-homing"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "SCTP uses UDP as its underlying transport"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "SCTP has no congestion control mechanism"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "SCTP is connectionless while TCP is connection-oriented"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.tcp_udp__65204",
   "topic": "networking",
   "subSkill": "tcp_udp",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How many steps are in the TCP connection establishment handshake?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "4 (SYN, SYN-ACK, ACK, DATA)"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "2 (SYN, ACK)"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "3 (SYN, SYN-ACK, ACK)"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "1 (SYN)"
       }
      ],
      "shape": "code"
     }
    ]
   }
  },
  {
   "questionId": "networking.tcp_udp__400564",
   "topic": "networking",
   "subSkill": "tcp_udp",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which statement best describes the relationship between cwnd and rwnd in determining how many bytes a TCP sender may have in flight?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The sender may have at most the maximum of cwnd and rwnd unacknowledged bytes outstanding at any moment in time"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The sender may have at most the product of cwnd and rwnd unacknowledged bytes outstanding at any moment in time"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The sender may have at most the sum of cwnd and rwnd unacknowledged bytes outstanding at any moment in time"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The sender may have at most the minimum of cwnd and rwnd unacknowledged bytes outstanding at any moment"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "networking.tcp_udp__65217",
   "topic": "networking",
   "subSkill": "tcp_udp",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How does TCP's sliding window mechanism determine the send window size?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The smaller of the receiver's window and the congestion window"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The sum of the receiver's window and the round-trip estimate"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The larger of the receiver's window and the congestion window"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The receiver's window alone, which the sender is told each ack"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.tcp_udp__51824",
   "topic": "networking",
   "subSkill": "tcp_udp",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "In Multipath QUIC, how is congestion control managed across paths?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Congestion control is disabled when multiple paths are active"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Each path maintains its own independent congestion control state"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The fastest path dictates the congestion window for all paths"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "A single shared congestion window covers all paths"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.tcp_udp__19632",
   "topic": "networking",
   "subSkill": "tcp_udp",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which protocol is commonly chosen for latency-sensitive media where occasional packet loss is acceptable?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "TCP, because its retransmission cost remains acceptable on realtime media paths"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "SCTP, because its strict per-stream ordering matches realtime media semantics best"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "UDP"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "QUIC reliable streams, because they retransmit lost frames before delivery to the app"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "networking.tcp_udp__100233",
   "topic": "networking",
   "subSkill": "tcp_udp",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Choosing UDP over TCP for a workload - which scenario is the classic textbook fit?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Bulk database replication stream that must guarantee every record arrives exactly once"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "File transfer between two hosts that must complete with zero missing or out-of-order bytes"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Real-time voice/video where late packets are useless and loss is preferable to delay"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Long-lived terminal session needing in-order keystroke delivery and reliable backpressure"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "networking.dns__200002",
   "topic": "networking",
   "subSkill": "dns",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which mail server should a sending MTA try first based on this answer?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "$ dig example.com MX +short\n10 alt1.mail.example.com.\n20 alt2.mail.example.com.",
    "label": "dns.ts"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The authoritative NS host instead of any listed MX target"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "alt2.mail.example.com because higher value means higher priority"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Either host because the preference field only affects weight"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "alt1.mail.example.com because it has the lowest preference"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.dns__15405",
   "topic": "networking",
   "subSkill": "dns",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What does the TTL on a DNS resource record primarily control?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "How long the client should keep the underlying TCP connection alive after the answer"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "How long authoritative servers retain the record on disk before zone refresh"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "How long the resolver waits for an answer before declaring the query timed out"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "How long downstream resolvers may cache that record before re-querying authority"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.dns__200511",
   "topic": "networking",
   "subSkill": "dns",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A new TLS certificate issuance is failing with the CA logging "
      },
      {
       "t": "code",
       "v": "CAA record forbids issuance"
      },
      {
       "t": "text",
       "v": ". Your CAA record reads "
      },
      {
       "t": "code",
       "v": "0 issue \"letsencrypt.org\""
      },
      {
       "t": "text",
       "v": ". You are ordering from a different ACME-compatible CA. The most likely cause?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The CAA record is missing an "
       },
       {
        "t": "code",
        "v": "issuewild"
       },
       {
        "t": "text",
        "v": " entry, so the CA cannot issue any wildcard."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The CAA record at the apex shadows the per-subdomain CAA the CA is querying for."
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The CAA record has an unsupported flag value, so the CA falls back to denying issuance."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The CAA record restricts issuance to Let's Encrypt only, so any other CA must refuse to issue."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "networking.dns__65336",
   "topic": "networking",
   "subSkill": "dns",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which sentence most accurately describes the role of a DNS resolver in name resolution?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Receive a client's query and look up the answer by traversing root, TLD, and authoritative servers as needed, caching along the way"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Receive domain registration requests from end users and submit them to the appropriate registry on their behalf"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Sign DNS responses with the zone's private key so downstream validators can confirm their authenticity"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Hold the canonical zone data and answer questions about names that are delegated to it directly by IANA"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "networking.dns__65320",
   "topic": "networking",
   "subSkill": "dns",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is a TXT record commonly used for?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Delegating a subdomain to another set of authoritative name servers"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Naming the hosts that accept mail for a domain, in order of preference"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Proving you own a domain, and carrying the mail authentication records"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Pointing a name at an address, which is what most lookups are after"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.dns__65657",
   "topic": "networking",
   "subSkill": "dns",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the lowest TTL value a DNS record may carry on the wire, per RFC 1035 - and what happens in practice?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Three hundred seconds: most large DNS providers reject smaller TTLs at the zone-write API to enforce cache hygiene"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Sixty seconds: RFC 1035 mandates this as a hard floor to prevent recursive resolvers from being overwhelmed"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Zero (meaning 'do not cache') though many recursive resolvers floor the effective TTL at 30-300 seconds to protect themselves"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Eighty-six thousand four hundred seconds: historically the standard one-day TTL, still required by the .com TLD registry"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "networking.dns__65646",
   "topic": "networking",
   "subSkill": "dns",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "After clearing the browser's DNS cache (e.g. chrome://net-internals/#dns), what does the browser actually do on the next navigation?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It flushes the in-zone cached records at the authoritative server for any name the user has visited recently in the session"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It re-queries its configured resolver path for each new hostname; the OS, ISP, and authoritative caches above it are unaffected"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It evicts both its own cache and the OS resolver cache, so the entire host's name resolution starts cold for every application"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It forces every recursive resolver upstream to evict the matching records by sending a special DNS RR-clearing query"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "networking.dns__19689",
   "topic": "networking",
   "subSkill": "dns",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the operational difference between a recursive resolver and an authoritative name server?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The recursive holds the zone data and signs records; the authoritative caches answers for downstream stubs to consume"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The recursive answers only A and AAAA queries; the authoritative is the only server that may answer MX, NS, and TXT"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The recursive walks the hierarchy on behalf of clients and caches answers; the authoritative serves the zones it is delegated for"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The recursive runs only over encrypted transports (DoH/DoT); the authoritative is restricted to classic UDP/53 by spec"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "networking.dns__65532",
   "topic": "networking",
   "subSkill": "dns",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How does DNS prefetching in modern browsers reduce page-load latency, and what is it not?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It downloads every record from the authoritative server on first page load, so subsequent navigations are offline-capable"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It resolves hostnames the page is likely to navigate to (href targets, hints) ahead of click, so the DNS round trip is already paid when the request is made"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It shares the browser's DNS cache with the OS resolver, populating it with every name the device has ever asked about"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It pre-opens TCP and TLS connections to all hostnames mentioned in the page, including those the user is unlikely to visit"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "networking.dns__19687",
   "topic": "networking",
   "subSkill": "dns",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A junior engineer asks why some DNS changes 'take a day to propagate' even though the authoritative server is updated immediately. Which DNS field is the dominant cause?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The maximum EDNS0 UDP payload size: large records must wait for TCP fallback to propagate"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The TTL on the cached resource record: resolvers serve the old answer until it expires"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The CNAME chain depth limit: resolvers stop following aliases mid-update until the chain settles"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The SOA REFRESH field: secondary servers do not pull the new zone until it ticks over"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "networking.http_protocol__401932",
   "topic": "networking",
   "subSkill": "http_protocol",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which statement best describes the HTTP/2 SETTINGS frame as defined by RFC 7540?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Carries connection-wide parameters such as initial window size and max streams"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Carries per-stream priority weights for the dependency tree the client built"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Carries header table updates the receiver must apply to its decoder context"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Carries flow control credit refills that reopen a previously exhausted stream"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.http_protocol__10075",
   "topic": "networking",
   "subSkill": "http_protocol",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which HTTP method is intended to retrieve a representation without changing server state?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "DELETE"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "POST"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "PATCH"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "GET"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.http_protocol__51839",
   "topic": "networking",
   "subSkill": "http_protocol",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the purpose of HTTP/3's PRIORITY_UPDATE frame introduced in RFC 9218?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It lets servers override client priority decisions for security-critical resources"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It enables priority inheritance between parent and child streams"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It allows clients to reprioritize previously opened streams without opening new ones"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It replaces the QUIC flow control mechanism with application-level priorities"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.http_protocol__502081",
   "topic": "networking",
   "subSkill": "http_protocol",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which statement best describes the QPACK header compression scheme used by HTTP/3?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Encoder uses a separate unidirectional stream so decoding tolerates out-of-order delivery"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Encoder reuses the HPACK dynamic table verbatim and synchronizes via header frames"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Encoder lazily emits literal values and skips the dynamic table on lossy connections"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Encoder relies on per-stream Huffman dictionaries negotiated during the QUIC handshake"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "networking.http_protocol__401921",
   "topic": "networking",
   "subSkill": "http_protocol",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which statement best describes the deprecation status of server push in HTTP/2?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Major browsers removed support after low utility and complex caching trade-offs"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Major browsers gated it behind a new opt-in Permissions-Policy directive instead"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Major browsers retained it but restricted it solely to same-document subresources"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Major browsers replaced it with WebTransport for proactive subresource delivery"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.http_protocol__65283",
   "topic": "networking",
   "subSkill": "http_protocol",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the difference between PUT and PATCH?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "PUT is idempotent; PATCH is not defined"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "PUT uses JSON; PATCH uses XML"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "PUT replaces the entire resource; PATCH applies partial modifications"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "They are interchangeable: both do partial updates"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.http_protocol__65574",
   "topic": "networking",
   "subSkill": "http_protocol",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the purpose of the HTTP If-Modified-Since header?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "To ask for the part of the resource that changed since the date that is given"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "To ask for the resource on the condition that it has changed since then"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "To tell the server when the client last cached the resource, for its logs alone"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "To ask the server for the date the resource last changed without fetching it"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.http_protocol__65521",
   "topic": "networking",
   "subSkill": "http_protocol",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What does a 500 Internal Server Error indicate?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The server hit something it did not expect and cannot answer"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The server is up but the service behind it did not answer in good time"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The server cannot find anything at the path the request asked for"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The server understood the request but declines to carry it out for you"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.http_protocol__100514",
   "topic": "networking",
   "subSkill": "http_protocol",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the correct characterization of an HTTP request line in version 1.1?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "A signed token followed by the cipher suite and the negotiated TLS version"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "A method token followed by a request target and the protocol version"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "A status code followed by a reason phrase and the negotiated content type"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "A binary frame header followed by stream identifier and payload length"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.http_protocol__1158294",
   "topic": "networking",
   "subSkill": "http_protocol",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How does an HTTP/3 server advertise to an HTTP/2 client that an HTTP/3 endpoint is available on a different UDP port?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "An ALPN list inside the TLS Server Hello advertising the h3 endpoint as fallback target"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "A Server-Push promise frame whose authority field references the h3 endpoint over UDP"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "An Alt-Svc response header or an HTTPS DNS resource record pointing at the h3 endpoint"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "An Upgrade response header pointing the client at the h3 endpoint over UDP transport"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "networking.cors__30540",
   "topic": "networking",
   "subSkill": "cors",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A banking app at "
      },
      {
       "t": "code",
       "v": "https://banking.example.com"
      },
      {
       "t": "text",
       "v": " serves users. An attacker creates "
      },
      {
       "t": "code",
       "v": "https://banking.example.com.evil.com"
      },
      {
       "t": "text",
       "v": ". The API has a CORS check using "
      },
      {
       "t": "code",
       "v": "origin.endsWith('.example.com')"
      },
      {
       "t": "text",
       "v": ". Will this bypass the CORS check?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Yes, JavaScript's endsWith ignores trailing TLD segments, so the comparison matches at the registrable domain boundary"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "No, browsers validate that the Origin header matches the TLS certificate's subjectAltName before any CORS check runs"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "No, the string ends with "
       },
       {
        "t": "code",
        "v": ".evil.com"
       },
       {
        "t": "text",
        "v": ", not "
       },
       {
        "t": "code",
        "v": ".example.com"
       },
       {
        "t": "text",
        "v": "; endsWith would correctly reject it, but "
       },
       {
        "t": "code",
        "v": "origin.includes('example.com')"
       },
       {
        "t": "text",
        "v": " or unanchored regex would not"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Yes, endsWith is a substring match and accepts the suffix "
       },
       {
        "t": "code",
        "v": ".example.com"
       },
       {
        "t": "text",
        "v": " anywhere in the origin string"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "networking.cors__65410",
   "topic": "networking",
   "subSkill": "cors",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What HTTP header does a server use to allow a specific origin to access its resources?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "CORS-Origin-Policy listing comma-separated allowed origin entries"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Access-Control-Allow-Origin"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "X-Allow-Origin paired with X-Allow-Credentials for credentialed reads"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Cross-Origin-Resource-Policy naming the origin that may embed it"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.cors__19708",
   "topic": "networking",
   "subSkill": "cors",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which request property forces a preflight OPTIONS before a cross-origin call the browser would otherwise send directly?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Sending a body larger than the safelisted text content length"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Custom non-simple headers like Authorization"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Adding query string parameters beyond the URL's path component"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Switching the request scheme from HTTP to HTTPS connections"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.cors__65423",
   "topic": "networking",
   "subSkill": "cors",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What was JSONP and why is it no longer recommended?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It fetched cross-origin data through a hidden frame, which the origin policy now blocks"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It fetched cross-origin data through a proxy on the same host, which cost a round trip"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It fetched cross-origin data through an image tag, which leaked the bytes in a header"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It fetched cross-origin data through a script tag, running another site's code"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.cors__65422",
   "topic": "networking",
   "subSkill": "cors",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Does the same-origin policy apply to server-to-server HTTP requests?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Only for TLS connections"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "No, SOP is a browser security policy only"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Yes, all HTTP requests are subject to SOP"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Only when using REST APIs"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.cors__65434",
   "topic": "networking",
   "subSkill": "cors",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the difference between 'same-origin' and 'same-site'?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The first applies to a request and the second to a cookie, so the two do not overlap"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The second needs the scheme, host and port to match, the first the registrable domain alone"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The first covers a subdomain while the second does not, which is the whole difference"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The first needs scheme, host and port to match, the second the domain and scheme"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.cors__65692",
   "topic": "networking",
   "subSkill": "cors",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the difference between CORS and CSP?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "CORS and CSP both govern script execution but apply at different points in the parse pipeline"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "CORS controls which origins can read your responses; CSP controls which resources your page can load"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "CORS is enforced server-side; CSP is enforced client-side on outbound fetches"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "CORS limits how many origins may load your page; CSP limits how many subresources you may fetch"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "networking.cors__65693",
   "topic": "networking",
   "subSkill": "cors",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the 'credentialless' mode for Cross-Origin-Embedder-Policy?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "A COEP mode that forwards cross-origin responses to the page without any header filtering"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "A COEP mode that loads cross-origin resources without credentials instead of blocking them, reducing the friction of enabling cross-origin isolation"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "A COEP mode that allows opaque embeds but blocks any CORS-enabled fetch from succeeding"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "A COEP mode that disables cross-origin isolation but still permits SharedArrayBuffer in workers"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "networking.cors__400006",
   "topic": "networking",
   "subSkill": "cors",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which statement best describes the consequence of terminating CORS at a reverse proxy versus the origin server?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Edge-terminated CORS converts the preflight OPTIONS into a GET so the origin never observes the method"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Edge-terminated CORS rewrites the Origin request header before the origin sees it for upstream consistency"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Edge-terminated CORS standardizes headers across services but can drift from origin-set headers if both add them"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Edge-terminated CORS encrypts the preflight body separately from the request body using a stronger cipher"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "networking.cors__65408",
   "topic": "networking",
   "subSkill": "cors",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What three components define an 'origin' in the same-origin policy?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "IP address, port, and protocol"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Scheme (protocol), host (domain), and port"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Domain, subdomain, and TLD"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Domain, path, and query string"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.rest_vs_grpc__65623",
   "topic": "networking",
   "subSkill": "rest_vs_grpc",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the difference between synchronous and asynchronous API calls?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The first lets the caller carry on until the response lands, the second blocks it throughout"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The first returns a body while the second returns a status the caller polls for later on"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The first runs on one thread while the second runs on a pool, which is the whole difference"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The first blocks the caller until the response lands, the second lets it carry on"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "networking.rest_vs_grpc__30547",
   "topic": "networking",
   "subSkill": "rest_vs_grpc",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A service mesh uses Envoy proxies between microservices. All inter-service calls today are REST over HTTP. The team wants to add gRPC for new services while leaving the already-deployed REST services untouched. What does the service mesh enable?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The sidecar translates between the two protocols, so an existing caller needs no change"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The sidecar terminates TLS for both, so the two protocols share one certificate and one trust domain"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The sidecar routes by path, so an existing caller reaches whichever service matches, whatever it speaks"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The sidecar buffers each call, so a slower service behind it cannot stall the caller in front of it"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "networking.rest_vs_grpc__200006",
   "topic": "networking",
   "subSkill": "rest_vs_grpc",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Comparing REST/JSON and gRPC/Protobuf payload encoding on the wire, what is the most accurate trade-off summary?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Protobuf is a verbose text encoding embedding the schema; JSON is fixed-width binary with no schema and smaller payloads"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Protobuf and JSON both inline the schema in each message; Protobuf is larger on wire but cheaper to parse on disk"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Protobuf is gzip-only and unparseable without TLS; JSON is encrypted by default and roughly identical in size always"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Protobuf is a compact binary encoding requiring a schema; JSON is text-based, self-describing, and larger on the wire"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "networking.rest_vs_grpc__65451",
   "topic": "networking",
   "subSkill": "rest_vs_grpc",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What does gRPC's deadline propagation feature do?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It records how long each call took, so a trace can show where the budget went"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It cancels the whole chain as soon as one call in it runs past its own deadline"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It carries the remaining time down the chain, so a nested call knows its budget"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It retries a call that missed its deadline, with the clock reset for the fresh attempt"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "networking.rest_vs_grpc__65455",
   "topic": "networking",
   "subSkill": "rest_vs_grpc",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What does a REST API use to identify resources?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Protocol Buffer message types"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Function names"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Socket addresses"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "URLs (Uniform Resource Locators)"
       }
      ],
      "shape": "code"
     }
    ]
   }
  },
  {
   "questionId": "networking.rest_vs_grpc__65638",
   "topic": "networking",
   "subSkill": "rest_vs_grpc",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is rate limiting in APIs?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Rejecting a client whose token has expired, which keeps the load steady"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Charging a client per request, which discourages a wasteful access pattern"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Queueing a client's requests so that the server handles them one after another in turn"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Capping how many requests a client can make in a window, which shields the server"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "networking.rest_vs_grpc__19712",
   "topic": "networking",
   "subSkill": "rest_vs_grpc",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How are application-level failures conveyed by a gRPC server to its caller?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "A JSON envelope with code and message fields in the response body payload"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "A grpc-status numeric code with optional grpc-message text in HTTP/2 trailers"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "An HTTP status code on the response line, mapped to the application error class"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "An HTTP/2 RST_STREAM frame whose error code mirrors the application failure"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.rest_vs_grpc__639082",
   "topic": "networking",
   "subSkill": "rest_vs_grpc",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A backend service exposes both gRPC and a REST gateway. The team wants one Protobuf definition to drive both surfaces in 2026 instead of duplicating handlers. Which option reflects current tooling?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Generate two SDKs with protoc-gen-go and protoc-gen-rest from separate proto trees"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Use Connect handlers, which serve gRPC, gRPC-Web, and Connect-JSON from one Protobuf service"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Write a parallel OpenAPI spec and reconcile drift with CI checks each release"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Use grpc-gateway with hand-written proto annotations as the only modern bridge"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.rest_vs_grpc__714056",
   "topic": "networking",
   "subSkill": "rest_vs_grpc",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Reviewing a Protobuf schema in 2026, you see a field marked "
      },
      {
       "t": "code",
       "v": "reserved 7 to 9;"
      },
      {
       "t": "text",
       "v": " after a field rename. Why is this the current recommended practice for backward-compatible evolution?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It forces the gRPC runtime to fall back to JSON encoding on those legacy tag positions"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It marks the fields as optional so generated code emits nullable accessors per language"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It blocks reuse of those tag numbers so old binaries cannot decode new fields into stale meanings"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It opts those tag numbers into the new Protobuf Editions strict-mode validation rules"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "networking.rest_vs_grpc__30544",
   "topic": "networking",
   "subSkill": "rest_vs_grpc",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "An internal microservice communicates frequently between services using REST/JSON. A performance analysis shows 30% of CPU time is in JSON serialization/deserialization. Which alternative reduces this overhead?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Switch to REST with XML which uses less CPU than JSON due to simpler parsing"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "gRPC with Protocol Buffers which uses binary serialization that is significantly faster and smaller than JSON text"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Use GraphQL which automatically generates optimized binary serialization from schemas"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Switch to REST with binary JSON (BSON) which the HTTP client handles transparently"
       }
      ],
      "shape": "code"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.hashing__103982",
   "topic": "crypto_basics",
   "subSkill": "hashing",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What does this Node.js snippet log?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "import { createHash } from 'node:crypto';\nconst a = createHash('sha256').update('a').digest('hex');\nconst b = createHash('sha256').update('a').digest('base64');\nconsole.log(a === b);",
    "label": "hashing.ts"
   },
   "widget": {
    "kind": "predict_output",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "false"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "throws"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "null!!"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "true"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.hashing__10142",
   "topic": "crypto_basics",
   "subSkill": "hashing",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A teammate proposes hashing a 4GB video file before uploading so the server can verify integrity. Which property of a cryptographic hash makes this plan work?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Arbitrary-size input is reduced to a fixed-size digest that changes if any byte of input changes"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The digest is compressed enough to act as a smaller stand-in upload to the server"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The digest seeds a stream cipher so the entire file content travels over the wire already encrypted"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The digest can be decrypted on the server to recover all of the original file bytes"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.hashing__300001",
   "topic": "crypto_basics",
   "subSkill": "hashing",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What distinguishes BLAKE3 from SHA-256?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "A NIST-approved primitive selected as the official successor to the SHA-2 family of hashes"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "A FIPS-validated hash mandated for new federal systems handling controlled unclassified data"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "A keyed-only construction whose unkeyed variant is reserved for digital signature workflows"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "A tree-mode hash designed for parallelism and high throughput on modern multi-core CPUs"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.hashing__300009",
   "topic": "crypto_basics",
   "subSkill": "hashing",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Why is CRC-32 unsuitable as a cryptographic integrity check?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It is a 32-bit checksum whose width is too small to hold a meaningful message digest output"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It depends on a static lookup table that has not been audited by any standards body group"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It is a linear checksum any attacker can patch to match a tampered message in seconds"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It uses bitwise operations that fail under unicode encoded inputs longer than one kilobyte"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.hashing__10145",
   "topic": "crypto_basics",
   "subSkill": "hashing",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A team is choosing between AES-encrypting passwords and hashing them with Argon2id. Why does an audit insist on the hashing path for the credentials table?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Encryption is reversible so a stolen key plus stolen ciphertext reveals every cleartext password"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Encryption requires a fresh nonce per call which a credentials table cannot persist safely"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Encryption is not standardized for short inputs so it returns inconsistent output on repeated runs"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Encryption produces shorter ciphertext than digests so collisions become statistically likely"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.hashing__200006",
   "topic": "crypto_basics",
   "subSkill": "hashing",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What does a salt provide in password hashing?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "A server side secret stored in environment configuration and applied to every credential"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "A counter that increments on each successful login and is mixed into the digest produced"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "A unique per-user random value that defeats precomputed rainbow tables and shared digests"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "A short fixed prefix that all credentials share to namespace the hash within the database"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.hashing__1992847",
   "topic": "crypto_basics",
   "subSkill": "hashing",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A protocol does "
      },
      {
       "t": "code",
       "v": "tag = HMAC-SHA256(k, ciphertext)"
      },
      {
       "t": "text",
       "v": " then sends "
      },
      {
       "t": "code",
       "v": "ciphertext || tag"
      },
      {
       "t": "text",
       "v": ". A red-team report says "
      },
      {
       "t": "code",
       "v": "decryption oracle: tag verified after plaintext is parsed"
      },
      {
       "t": "text",
       "v": ". What rewrite of the verification path closes the oracle?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Verify the tag after the per-record sequence number has been incremented"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Verify the tag while decryption streams chunks through the parser stage"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Verify the tag in constant time before any parsing or decryption runs"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Verify the tag once the parsed plaintext schema is known to be well-formed"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.hashing__111327",
   "topic": "crypto_basics",
   "subSkill": "hashing",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What does this Node.js snippet log for HMAC-SHA512 hex tag length?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "import { createHmac } from 'node:crypto';\nconst t = createHmac('sha512', 'k').update('m').digest('hex');\nconsole.log(t.length);",
    "label": "hashing.ts"
   },
   "widget": {
    "kind": "predict_output",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "064"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "256"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "128"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "512"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.hashing__17211",
   "topic": "crypto_basics",
   "subSkill": "hashing",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How should a system handle a hash algorithm upgrade, for example migrating from SHA-1 to SHA-256?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Store both the old and new digests side by side permanently and verify against whichever matches"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Re-hash each password on next successful login, and compute both digests during the transition"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Keep verifying against the old hash and defer switching until every account has logged in once"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Force every user to reset their password on next login so all rows adopt the new hash at once"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.hashing__17223",
   "topic": "crypto_basics",
   "subSkill": "hashing",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the impact of quantum computing on currently used hash functions?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Only hashes with output above 512 bits stay vulnerable, while shorter digests like SHA-256 become unbreakable"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Shor's algorithm reduces hash collision resistance to logarithmic complexity, instantly forging any digest"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Quantum computers break all cryptographic hash functions in polynomial time, so SHA-256 offers no resistance"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Grover's search halves the preimage exponent, so SHA-256 still offers 128-bit security against quantum attack"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.symmetric_encryption__118273",
   "topic": "crypto_basics",
   "subSkill": "symmetric_encryption",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Comparing AES-GCM with raw AES-CTR for an application API, what does AES-GCM add?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Compression of plaintext before encryption to shrink network bandwidth"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Asymmetric key wrapping so each recipient gets a unique session key"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Larger cipher block size that better protects against birthday-bound collisions"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Built-in authentication tag that detects tampering of the ciphertext payload"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.symmetric_encryption__17259",
   "topic": "crypto_basics",
   "subSkill": "symmetric_encryption",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Design an encryption scheme for a multi-tenant SaaS application where each tenant must have isolated encryption keys, keys must be replaceable without downtime, and a single compromised key must not affect other tenants."
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Implement hierarchical envelope encryption: tenant-specific KEKs wrap per-data-object DEKs, with KEKs stored in a hardware security module. Key rotation re-wraps DEKs with new KEK without re-encrypting data. Tenant isolation is enforced by key hierarchy."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Encrypt all tenant data with the same key and use access control for isolation"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Let each tenant manage their own encryption independently"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Use a single master key for all tenants for simplicity"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.symmetric_encryption__17241",
   "topic": "crypto_basics",
   "subSkill": "symmetric_encryption",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How does AES-GCM construct its authentication tag?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The tag is the final ciphertext block of the encrypted message"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "GCM runs HMAC-SHA256 over the ciphertext to produce the tag"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "GCM computes a GHASH polynomial over the ciphertext and encrypts it"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The tag is a simple checksum taken over all of the ciphertext blocks"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.symmetric_encryption__200634",
   "topic": "crypto_basics",
   "subSkill": "symmetric_encryption",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What error message does the snippet print?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "const { createCipheriv, randomBytes } = require('crypto');\ntry {\n  createCipheriv('aes-256-gcm', randomBytes(16), randomBytes(12));\n} catch (e) { console.log(e.message); }",
    "label": "symmetric-encryption.ts"
   },
   "widget": {
    "kind": "predict_output",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Unknown cipher name"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Unsupported state"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Invalid key length"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Invalid IV length"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.symmetric_encryption__17252",
   "topic": "crypto_basics",
   "subSkill": "symmetric_encryption",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What are the security tradeoffs between deterministic encryption and randomized encryption in searchable encryption schemes?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Deterministic mode allows equality search but leaks frequency, while randomized mode hides all patterns"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Both schemes leak the same frequency information, so the choice is purely a performance decision"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Deterministic encryption hides frequency patterns by adding a fresh random salt to every value"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Randomized encryption enables equality search on the server while deterministic encryption hides frequency patterns"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.symmetric_encryption__200813",
   "topic": "crypto_basics",
   "subSkill": "symmetric_encryption",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How does CTR mode produce ciphertext from a plaintext segment?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It feeds the previous ciphertext block into the next block to act as an initialization vector."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It encrypts a counter under the key and XORs the result with each plaintext segment."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It encrypts the plaintext block directly with the key without using any auxiliary input."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It pads the plaintext to the block boundary and signs the result with HMAC-SHA256."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.symmetric_encryption__17232",
   "topic": "crypto_basics",
   "subSkill": "symmetric_encryption",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the difference between AES-CBC and AES-GCM?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "CBC provides confidentiality only and needs a separately applied MAC for integrity; GCM is an AEAD that encrypts and authenticates in one operation"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "CBC encrypts each block independently exactly like ECB, while GCM chains blocks together to hide repeated plaintext patterns"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "CBC carries a built-in integrity tag over the padding inside every block; GCM provides confidentiality alone and leaves tamper detection to the caller"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Both are AEAD modes, but NIST withdrew GCM after a nonce-reuse flaw, and CBC with random padding is now the only approved choice"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.symmetric_encryption__100315",
   "topic": "crypto_basics",
   "subSkill": "symmetric_encryption",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What kind of cryptographic primitive is AES-GCM?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It is a digital signature algorithm built on top of elliptic-curve arithmetic."
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It is a key-agreement protocol that derives a shared secret over an insecure channel."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It is a password hashing scheme tuned for memory-hard verification on servers."
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It is an authenticated encryption mode producing ciphertext plus an integrity tag."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.symmetric_encryption__273450",
   "topic": "crypto_basics",
   "subSkill": "symmetric_encryption",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Comparing AES-GCM with AES-GCM-SIV, what failure mode does the SIV variant specifically address?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Throughput collapse on long messages due to GHASH polynomial saturation"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Plaintext malleability when an attacker flips a few bits in the ciphertext stream"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Catastrophic key recovery and forgery when a nonce is repeated under one key"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Side-channel cache-timing leaks present in software AES table-lookup paths"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.symmetric_encryption__301421",
   "topic": "crypto_basics",
   "subSkill": "symmetric_encryption",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What does a stream cipher's keystream consist of?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "A pseudorandom byte sequence XORed with plaintext to produce ciphertext output."
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "A fixed-size permutation that maps plaintext blocks deterministically to ciphertext."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "A signed digest appended to each ciphertext block for transport integrity checks."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "A ciphertext block fed into the cipher to produce the next ciphertext segment."
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.asymmetric_encryption__17263",
   "topic": "crypto_basics",
   "subSkill": "asymmetric_encryption",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the main advantage of asymmetric encryption over symmetric encryption?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The security you get per bit of key is stronger, so shorter keys do the same job"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Asymmetric encryption runs faster than symmetric encryption because it uses shorter keys"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "No need to share a secret key in advance because the public key can be freely distributed"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Asymmetric encryption produces ciphertext that is smaller than the plaintext that it protects"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.asymmetric_encryption__405671",
   "topic": "crypto_basics",
   "subSkill": "asymmetric_encryption",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How does ML-KEM (FIPS 203) differ from classical asymmetric primitives?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It is a lattice-based key-encapsulation mechanism standardized for resistance against quantum cryptanalytic attacks."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It is a code-based encryption scheme whose public keys consist of a permuted parity-check matrix over a small field."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It is a hash-based digital signature scheme whose state must be advanced once per signing event by the signer."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It is an isogeny-based key agreement primitive built on supersingular elliptic-curve walks between distinct curves."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.asymmetric_encryption__17286",
   "topic": "crypto_basics",
   "subSkill": "asymmetric_encryption",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How do post-quantum algorithms like ML-KEM (Kyber) provide security?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "They use one-time pads generated by quantum key distribution"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "They use extremely large RSA keys that quantum computers cannot factor"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "They rely on the Learning With Errors (LWE) problem: recovering a secret from noisy linear equations over a lattice, which is believed to be hard even for quantum computers"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "They combine multiple classical algorithms for redundancy"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.asymmetric_encryption__17292",
   "topic": "crypto_basics",
   "subSkill": "asymmetric_encryption",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How does the RSA key generation process ensure the generated keys are secure?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "By testing the finished keys against every known factoring attack before they are put into deployment"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "By generating several key pairs and keeping the one that benchmarks fastest on the target hardware"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "By checking each finished key against a public database of known weak or previously leaked key material and rejecting matches"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "By picking p and q that are sufficiently large, drawn from a CSPRNG, and confirmed prime by probabilistic testing"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.asymmetric_encryption__257301",
   "topic": "crypto_basics",
   "subSkill": "asymmetric_encryption",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What does the following Node.js snippet print?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "const { generateKeyPairSync, sign } = require('crypto');\nconst { privateKey } = generateKeyPairSync('ed25519');\nconst sig = sign(null, Buffer.from('hello'), privateKey);\nconsole.log(sig.length);",
    "label": "asymmetric-encryption.ts"
   },
   "widget": {
    "kind": "predict_output",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "32"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "64"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "96"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "16"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.asymmetric_encryption__1582904",
   "topic": "crypto_basics",
   "subSkill": "asymmetric_encryption",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A team is adopting post-quantum readiness for an internal envelope-encryption service. Per current Filippo-style guidance, what is the recommended deployment strategy in 2025-2026?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Defer: keep RSA-OAEP-3072 only until ML-KEM ships in stable OpenSSL"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Hybrid: combine X25519 ECDH shared secret with ML-KEM encapsulated secret"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Wholesale: replace all X25519 ECDH paths with NTRU-Prime only KEM mode"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Wholesale: replace all the X25519 ECDH paths with ML-KEM only encapsulation"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.asymmetric_encryption__17275",
   "topic": "crypto_basics",
   "subSkill": "asymmetric_encryption",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How does the RSA encryption process work mathematically at a high level?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "RSA XORs a key into the message, so ciphertext = plaintext XOR e; recovery XORs the very same value back in"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Pick two large primes p and q and set n = p*q; then ciphertext = plaintext^e mod n and plaintext = ciphertext^d mod n"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "RSA adds and subtracts two large primes, so ciphertext = plaintext + e mod n; to recover it you just subtract d mod n"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "RSA hashes the message, so ciphertext = H(plaintext); the receiver recomputes the hash with d to recover it"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.asymmetric_encryption__17273",
   "topic": "crypto_basics",
   "subSkill": "asymmetric_encryption",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the relationship between asymmetric encryption and digital certificates?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Certificates are encrypted versions of public keys"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "A certificate binds a public key to a verified identity"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Digital certificates are just another kind of asymmetric key pair"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Certificates replace the need for asymmetric encryption"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.asymmetric_encryption__904718",
   "topic": "crypto_basics",
   "subSkill": "asymmetric_encryption",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "NIST finalised a post-quantum key encapsulation standard recently. Which mechanism is intended to replace classical Diffie-Hellman key agreement in hybrid deployments?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "ML-DSA (FIPS 204), formerly known as CRYSTALS-Dilithium sig"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "FN-DSA (FIPS 206), formerly known as Falcon lattice signature"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "SLH-DSA (FIPS 205), formerly known as SPHINCS+ stateless sig"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "ML-KEM (FIPS 203), formerly known as CRYSTALS-Kyber KEM"
       }
      ],
      "shape": "code"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.asymmetric_encryption__17294",
   "topic": "crypto_basics",
   "subSkill": "asymmetric_encryption",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Design a protocol for a messaging system that keeps conversations confidential, leaves earlier traffic unreadable if a device is later seized, and pushes an attacker who stole current keys back out as the chat continues."
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Use the Double Ratchet: a DH ratchet per message chain and a symmetric ratchet, giving forward secrecy and self-healing"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Use static RSA encryption for every message: the long-term key pair alone protects the whole conversation history"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Use perfect forward secrecy from one ECDHE exchange at session start: a single shared secret covers that entire session"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Rotate the long-term key pair after every message: each fresh pair supersedes the old one for all later traffic"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.digital_signatures__17303",
   "topic": "crypto_basics",
   "subSkill": "digital_signatures",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is non-repudiation in the context of digital signatures?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The signature cannot be removed from the document once it has been applied to the file"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The signature proves that the recipient actually opened and read the document in full"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The signed document cannot be transmitted over an unsecured channel such as ordinary email or a plain FTP drop"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The signer cannot deny signing the document, as only their private key could have produced the signature"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.digital_signatures__220528",
   "topic": "crypto_basics",
   "subSkill": "digital_signatures",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What does message canonicalisation before signing do to the payload?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It encrypts the structured payload under a transport key prior to the digest step."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It rotates the field ordering on every send so that identical bodies produce entirely new digests."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It serialises the payload into a single byte sequence so every verifier hashes the same input."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It strips the digest header so that verifiers can recompute it from the body bytes only."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.digital_signatures__230289",
   "topic": "crypto_basics",
   "subSkill": "digital_signatures",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What does the EMSA-PSS encoding step do inside RSA-PSS signing?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It encrypts the message digest under the recipient's modulus before any signing happens."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It mixes a random salt with the message digest and expands the result via a mask function."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It pads the digest with deterministic ASN.1 bytes and then signs the whole padded structure as is."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It compresses the digest into half its width so the modular exponent stays inexpensive."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.digital_signatures__210143",
   "topic": "crypto_basics",
   "subSkill": "digital_signatures",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What security properties does a digital signature give a message?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Anonymous delivery that hides the originator from every downstream relay."
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Confidentiality of the message body so that no intermediary can read its contents."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Authenticity and integrity verifiable by anyone holding the signer's public key."
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Compression of the payload so that bandwidth between two parties shrinks."
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.digital_signatures__100412",
   "topic": "crypto_basics",
   "subSkill": "digital_signatures",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What does the snippet print?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "const { generateKeyPairSync, sign } = require('crypto');\nconst { publicKey, privateKey } = generateKeyPairSync('ed25519');\nconst sig = sign(null, Buffer.from('msg'), privateKey);\nconsole.log(sig.length);",
    "label": "digital-signatures.ts"
   },
   "widget": {
    "kind": "predict_output",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "64"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "32"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "48"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "96"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.digital_signatures__230837",
   "topic": "crypto_basics",
   "subSkill": "digital_signatures",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which characterization of a typical X.509 certificate signature is correct?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Each intermediate strips the issuer's signature and reissues a fresh tag of equal length."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The issuer signs the DER-encoded TBSCertificate field using its own private key."
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The verifier signs the entire certificate so the chain accumulates witness signatures."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The subject signs the issuer's CRL distribution point list using a session key from TLS."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.digital_signatures__220636",
   "topic": "crypto_basics",
   "subSkill": "digital_signatures",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What role does a nonce or timestamp play in a signed request envelope?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It compresses the request envelope so the resulting digest fits inside a fixed-size buffer."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It encrypts the request body so an eavesdropper cannot read its sensitive fields."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It binds each signature to a fresh context so a captured payload cannot be replayed later."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It rotates the signing key after each request so that long-term keys will never sign twice."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.digital_signatures__733904",
   "topic": "crypto_basics",
   "subSkill": "digital_signatures",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "You are designing JWT verification for a multi-tenant API. Recent guidance flags one historical pitfall as the primary cause of compromise. What is it?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Trusting the token's alg header rather than pinning a key"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Including the kid header field in the unverified token claims"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Embedding the JWT inside an Authorization Bearer scheme value"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Using RS256 instead of HS256 across all tenants of the API"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.digital_signatures__17308",
   "topic": "crypto_basics",
   "subSkill": "digital_signatures",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is timestamping in digital signatures and why is it important?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Timestamps are required by law before any digital signature becomes legally binding in court"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Adding a timestamp to the signature makes the underlying cryptography measurably stronger over time"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "A trusted timestamp proves when the document was signed, so the signature stays valid after the certificate expires"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Timestamps record the moment at which each signature was last verified by a client rather than when it was actually signed"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.digital_signatures__1278341",
   "topic": "crypto_basics",
   "subSkill": "digital_signatures",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "You are advising a payments platform on a hybrid PQ migration for its signing path. They want classical security today plus PQ security once standards mature, with no protocol break later. What composition is the safest design?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "XOR the ECDSA signature bytes with the ML-DSA signature output before send"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Concatenate independent ECDSA and ML-DSA signatures and require both verify"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Choose ECDSA or ML-DSA per request based on a hash of the message contents"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Sign with ECDSA, then sign that signature again with the ML-DSA private key"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.tls_certificates__30689",
   "topic": "crypto_basics",
   "subSkill": "tls_certificates",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the difference between TLS 1.2 and TLS 1.3?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "TLS 1.3 dropped insecure algorithms, cut the handshake to one round trip, mandates forward secrecy, and simplified suites"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "TLS 1.3 listens on its own dedicated TCP port and clients must explicitly opt in to that port to negotiate the newer version"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "TLS 1.3 trades throughput for security and runs measurably slower than 1.2 on identical hardware and identical workloads"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "TLS 1.3 requires a different certificate format from TLS 1.2 and existing X.509 chains must be reissued before upgrade"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.tls_certificates__30687",
   "topic": "crypto_basics",
   "subSkill": "tls_certificates",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is certificate pinning and what problem does it solve?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Physically affixing the hardware security module that holds the server's private key to a locked rack in the datacenter"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Configuring a client to accept only specific certificates for a domain, so forged certificates from a compromised CA fail"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Concatenating several backup certificates into the same chain bundle so that any one of them can be presented at handshake"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Associating the certificate with a fixed server IP so DNS-based load balancing cannot serve the cert from another host"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.tls_certificates__51026",
   "topic": "crypto_basics",
   "subSkill": "tls_certificates",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How should TLS be configured for an API that must support both modern clients and legacy devices?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Drop down to the oldest TLS version anyone in the fleet still uses, since the lowest common denominator maximizes compatibility"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Prefer modern cipher suites in the negotiation order while still accepting backward-compatible options, and monitor client usage"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Operate two completely separate API endpoints (one strict-modern and one legacy) and require clients to choose at integration time"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Support only the very latest TLS version and most recent cipher suites, accepting that all legacy devices will fail to connect"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.tls_certificates__30681",
   "topic": "crypto_basics",
   "subSkill": "tls_certificates",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Why does a browser accept the server's public key during a TLS handshake instead of trusting whatever key arrives?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The certificate is a license issued by a regulator confirming the operator is allowed to run a website legally"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The certificate is a server config file that tells the browser which cipher suites and protocol versions to use"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The certificate encrypts website content at rest and proves the server is storing data safely on disk"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The certificate binds the hostname to a public key, signed by a CA already in the browser root store"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.tls_certificates__30691",
   "topic": "crypto_basics",
   "subSkill": "tls_certificates",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is certificate transparency (CT) and how does it work?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "CT encrypts the certificate metadata for privacy and prevents network observers from learning which certs were issued"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "CT requires CAs to submit every issued certificate to public append-only logs that anyone can monitor"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "CT is a server-side caching layer that warms certificate validation results so subsequent TLS handshakes complete faster"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "CT is a renewal helper that watches a CA's queue and automatically replaces a leaf certificate before expiry"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.tls_certificates__30683",
   "topic": "crypto_basics",
   "subSkill": "tls_certificates",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What happens when a TLS certificate expires?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The browser silently downgrades and continues delivering the page over an unencrypted HTTP connection instead"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Browsers show a security warning and block the connection, treating the expired certificate as untrusted"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The certificate auto-renews at the validity boundary using the original CSR submitted at first issuance time"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Nothing visible happens because the browser keeps delivering the page over the existing symmetric session encryption"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.tls_certificates__30698",
   "topic": "crypto_basics",
   "subSkill": "tls_certificates",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "During a TLS 1.2 handshake, the client and server must agree on a cipher suite. How is that selection made?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Both ends negotiate a brand-new suite for every record exchanged inside the connection lifetime across the open TLS session"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The client advertises a prioritized list of supported suites; the server picks one acceptable to both, preferring forward-secret AEAD suites"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The server picks the cipher suite unilaterally; the client must support whatever the server announces during ServerHello regardless of policy"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The client picks unilaterally from a built-in list and the server is required to honor whatever first entry is sent each time"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.tls_certificates__51025",
   "topic": "crypto_basics",
   "subSkill": "tls_certificates",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is Encrypted Client Hello (ECH) and what privacy problem does it solve?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "ECH encrypts the SNI and other sensitive handshake fields, so observers cannot see which site a browser is reaching"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "ECH encrypts the server's leaf certificate inside the ServerHello so an observer cannot identify the issuing CA by sight"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "ECH is a separate top-level alternative to HTTPS that some privacy-conscious users opt into for end-to-end traffic protection"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "ECH replaces the X.509 certificate with a privacy-preserving credential format that exposes only an anonymous public key"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.tls_certificates__30696",
   "topic": "crypto_basics",
   "subSkill": "tls_certificates",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the role of the Server Name Indication (SNI) extension in TLS?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "SNI encrypts the requested hostname inside the ClientHello so that on-path observers cannot see which site the user is loading"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "SNI is a routing helper that lets a client send the same TLS request through several upstream relays to bypass restrictions"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "SNI is the field where client and server negotiate the TLS protocol version and the maximum supported record-layer parameters"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "SNI carries the target hostname during the handshake, so a single IP address can host many separate TLS sites"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.tls_certificates__410921",
   "topic": "crypto_basics",
   "subSkill": "tls_certificates",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What does the snippet print?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "const { checkServerIdentity } = require('tls');\nconst cert = { subjectaltname: 'DNS:*.example.com' };\nconst result = checkServerIdentity('a.b.example.com', cert);\nconsole.log(result && result.constructor.name);",
    "label": "tls-certificates.ts"
   },
   "widget": {
    "kind": "predict_output",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Error"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "null"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "true"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "false"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.key_management__101817",
   "topic": "crypto_basics",
   "subSkill": "key_management",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which primitive is the right choice for storing user login credentials at rest?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "A symmetric authenticated cipher applied to each credential under a single shared key held by the application server."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "A keyed message authentication code applied to each credential so the server can verify integrity on every login."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "A memory-hard password hashing function applied per credential with a unique random salt and tunable cost parameters."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "A fast cryptographic digest applied directly to the credential so logins remain quick even at very large user populations."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.key_management__203187",
   "topic": "crypto_basics",
   "subSkill": "key_management",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What does the term 'pepper' denote in password storage, as distinct from a salt?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "A single application-wide secret held outside the credentials database and mixed into every password before hashing."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "A short user-chosen suffix added to the password so account holders effectively control their own slow-hashing cost parameter."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "A unique random per-credential value stored alongside the hash so identical user passwords yield distinct stored output values."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "A monotonic counter incremented on every authentication so repeated cracking attempts produce different inputs each round."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.key_management__30649",
   "topic": "crypto_basics",
   "subSkill": "key_management",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A team decides to replace its long-lived AES key every quarter with a fresh one. What threat does this scheduled replacement most directly limit?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The chance that one of the team's engineers can no longer access older archived records"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The blast radius of a key compromise and the ciphertext exposed under any single key"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The risk that the underlying cipher itself becomes mathematically broken inside that quarter"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The likelihood that the random number generator outputs a previously-seen key value twice"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.key_management__30657",
   "topic": "crypto_basics",
   "subSkill": "key_management",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is split knowledge in key management?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Dividing a key into shares held by different custodians so that no single person ever holds the complete key"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Encrypting each class of data under its own distinct key so that one compromised key exposes only one data type"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Replicating the key across several geographic regions so that losing any single region cannot make the data unrecoverable"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Storing the key in one place while keeping its access-control policy in a separate system administered by a different team"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.key_management__200831",
   "topic": "crypto_basics",
   "subSkill": "key_management",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the final printed value?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "from cryptography.hazmat.primitives.ciphers.aead import AESGCM\nimport os\nkey = AESGCM.generate_key(bit_length=256)\naead = AESGCM(key)\nnonce = os.urandom(12)\nct = aead.encrypt(nonce, b'', None)\nprint(len(ct))",
    "label": "key-management.ts"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "16"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "12"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "32"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "24"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.key_management__200774",
   "topic": "crypto_basics",
   "subSkill": "key_management",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the printed length?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "import base64, os\nkey = os.urandom(32)\nb64 = base64.b64encode(key).decode()\nprint(len(b64))",
    "label": "key-management.ts"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "44"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "32"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "60"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "24"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.key_management__30675",
   "topic": "crypto_basics",
   "subSkill": "key_management",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "An end-to-end encrypted group messaging product wants to send a single ciphertext to many recipients. Why does standard AES-GCM key commitment status matter for this design?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Without key commitment, one ciphertext can decrypt to different plaintexts under different recipient keys"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Without key commitment, the protocol must fall back to a sequential per-recipient encryption pass at the sender"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Without key commitment, AES-GCM authentication tags grow proportionally to the number of intended recipients"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Without key commitment, only the sender can verify the integrity of the ciphertext after transmission"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.key_management__202311",
   "topic": "crypto_basics",
   "subSkill": "key_management",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "In password hashing, what is a salt?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "A user-chosen string concatenated to the password so that users with strong personal phrases gain extra resistance against offline guessing."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "A fixed secret shared across the database so an attacker without it cannot run a dictionary attack on any leaked hash record."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "A unique random value stored alongside each hash so identical passwords produce different hashes and precomputed tables become useless."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "A counter incremented on every login attempt so repeated guesses against the same account get progressively more expensive."
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.key_management__30651",
   "topic": "crypto_basics",
   "subSkill": "key_management",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A platform team grants every backend service decrypt permission on every customer key 'so deploys don't break'. Which principle does this most directly violate?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Defense in depth: every cryptographic operation must be guarded by at least two independent controls"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Least privilege: each principal gets only the keys and key operations its actual workload requires"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Key separation: each piece of data must be encrypted under a distinct cryptographic key of its own"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Separation of duties: engineers who write the code must not also operate production deployments"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.key_management__30663",
   "topic": "crypto_basics",
   "subSkill": "key_management",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "IT must be able to unlock an encrypted laptop after the employee who owned it leaves. Which design satisfies this without granting IT routine access to the user's data?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Hold an unencrypted copy of every disk key in a network share that only the IT directory group reads"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Make IT a co-owner of every encrypted volume from the moment the laptop is provisioned to the user"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Generate the disk key from a deterministic function of the user's own employee ID so that IT can reproduce it"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Escrow the disk key with multi-person authorization and an immutable audit log of every recovery operation"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "networking.tls_ssl__51855",
   "topic": "networking",
   "subSkill": "tls_ssl",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How much additional data does a hybrid post-quantum TLS 1.3 handshake transfer compared to a classical handshake?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Approximately 160,000 additional bytes"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Approximately 100 additional bytes"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Approximately 16,000 additional bytes"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Approximately 1600 additional bytes"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.tls_ssl__51861",
   "topic": "networking",
   "subSkill": "tls_ssl",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Why is self-hosted ECH deployment still limited as of early 2026?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It needs a browser flag on the client side, which few readers have ever turned on"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It needs the keys published in DNS and rotated frequently, and the tooling is thin"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It needs the origin to speak the newest transport, which most stacks still lack"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It needs a second certificate for the outer name, which an authority will not issue"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "networking.tls_ssl__300043",
   "topic": "networking",
   "subSkill": "tls_ssl",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Comparing classic SNI with Encrypted Client Hello (ECH), what threat does ECH address that SNI exposed?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "ECH encrypts the server name to a public key fetched via DNS, hiding the hostname from on-path observers"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "ECH downgrades the handshake to RSA key exchange so legacy observers can audit the connection"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "ECH replaces the certificate chain with a single ephemeral key signed by the resolver itself"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "ECH moves the SNI field into the TCP options header so middleboxes can rewrite it safely"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "networking.tls_ssl__51853",
   "topic": "networking",
   "subSkill": "tls_ssl",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What percentage of browsers supported Encrypted Client Hello (ECH) by early 2026?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Approximately 59%"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Approximately 15%"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Approximately 100%"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Approximately 85%"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.tls_ssl__51854",
   "topic": "networking",
   "subSkill": "tls_ssl",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is a hybrid post-quantum key exchange in TLS 1.3, and why is it used instead of pure post-quantum?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It combines a classical algorithm (ECDHE) with a PQ algorithm (ML-KEM) so security holds even if one is broken"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It alternates between quantum and classical keys on each TLS record"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It uses post-quantum algorithms for the handshake and classical for data encryption"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It runs two parallel TLS handshakes with different cipher suites for redundancy"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.tls_ssl__19693",
   "topic": "networking",
   "subSkill": "tls_ssl",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Why does TLS 1.3 mandate ephemeral key exchange (no static-RSA option)?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "To remove the certificate message and shrink the ClientHello payload bytes"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "To give every session forward secrecy against a future leak of the cert's private key"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "To shorten the cipher-suite list so middleboxes do not parse legacy combinations"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "To allow the server to skip CertificateVerify entirely on resumed connections"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.tls_ssl__500776",
   "topic": "networking",
   "subSkill": "tls_ssl",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "An edge platform reports degraded handshake completion on a single anycast POP after enabling QUIC. Captures show ClientHello arriving fine, but ServerHello+Finished+1-RTT keys take an extra round-trip. Address validation tokens are being issued before the handshake completes. What is the cause?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Address validation rotated the AEAD key during ClientHello so the keys had to be re-derived first"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Address validation forced a Retry packet so the client had to re-send ClientHello with the token"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Address validation deferred the certificate exchange so the chain was sent after the application data"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Address validation upgraded the connection ID so the client had to re-negotiate the path identifier"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "networking.tls_ssl__200204",
   "topic": "networking",
   "subSkill": "tls_ssl",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A Python script wraps a TCP socket with ssl.create_default_context() but passes a hostname that does not match the certificate. What exception class name is printed?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "import socket, ssl\nctx = ssl.create_default_context()\nwith socket.create_connection(('www.cloudflare.com', 443)) as raw:\n    try:\n        ctx.wrap_socket(raw, server_hostname='example.invalid').do_handshake()\n    except Exception as e:\n        print(type(e).__name__)",
    "label": "tls-ssl.ts"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "SSLZeroReturnExceptionRaised"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "SSLCertVerificationError"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "SSLEarlyEOFErrorRaised"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "SSLWantReadHandshakeError"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.tls_ssl__300305",
   "topic": "networking",
   "subSkill": "tls_ssl",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A Node.js script connects to a typical public site with rejectUnauthorized:true and prints peerCertificate.issuer.O for a freshly-issued public cert. What organization is printed?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "const tls = require('node:tls');\nconst s = tls.connect({\n  host: 'example.org',\n  port: 443,\n  servername: 'example.org',\n  rejectUnauthorized: true,\n}, () => {\n  console.log(s.getPeerCertificate().issuer.O);\n  s.end();\n});",
    "label": "tls-ssl.ts"
   },
   "widget": {
    "kind": "predict_output",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Lets Encrypt"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "DigiCert Inc"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "GlobalSign nv"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Sectigo Ltd."
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.tls_ssl__201074",
   "topic": "networking",
   "subSkill": "tls_ssl",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Logs from a service-to-service call show 'tls: failed to verify certificate: x509: certificate signed by unknown authority'. The leaf is valid in a browser. What is the cause?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The calling service's trust store is missing the intermediate CA that signed the leaf cert"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The calling service stripped the SNI extension so the server returned the default cert chain"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The calling service is rejecting the certificate because its SAN list contains a wildcard entry"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The calling service negotiated a cipher suite that the leaf certificate's signature cannot support"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "networking.cdn_networking__65490",
   "topic": "networking",
   "subSkill": "cdn_networking",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is a CDN cache key?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The label a rule matches on to decide which objects it applies its policy to"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The hash of the response body, which lets two edges recognise the same object"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The token the edge sends the origin so a purge can name the object it removes"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The identifier an object is stored and looked up under, the URL as a rule"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.cdn_networking__400562",
   "topic": "networking",
   "subSkill": "cdn_networking",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A purge worker fires a tag-based invalidation. Three nodes hold the surrogate key; one is offline. What does the snippet log?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "async function purgeAll(nodes, key) {\n  const r = await Promise.allSettled(\n    nodes.map(n => n.online ? Promise.resolve(true) : Promise.reject('down'))\n  );\n  const ok = r.filter(x => x.status === 'fulfilled').length;\n  const bad = r.length - ok;\n  console.log(`purged=${ok}, failed=${bad}, key=${key}`);\n}\npurgeAll([{online:true},{online:true},{online:false}], 'catalog-v9');",
    "label": "cdn-networking.ts"
   },
   "widget": {
    "kind": "predict_output",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "purged=2, failed=1, key=catalog_v9"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "purged=2, failed=1, key=catalog-v9"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "purged=1, failed=2, key=catalog-v9"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "purged=3, failed=0, key=catalog-v9"
       }
      ],
      "shape": "code"
     }
    ]
   }
  },
  {
   "questionId": "networking.cdn_networking__65496",
   "topic": "networking",
   "subSkill": "cdn_networking",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What HTTP header tells a CDN not to cache a response?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "X-No-Cache: true"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Cache-Control: no-store"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Pragma: no-cdn"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "CDN-Cache: disabled"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.cdn_networking__836419",
   "topic": "networking",
   "subSkill": "cdn_networking",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A dev sets Cache-Control: private, max-age=600 on an API hoping the user's browser caches it while the CDN does not. The CDN still serves cached responses to other users. Why?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "Cache-Control: private, max-age=600",
    "label": "cdn-networking.ts"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The CDN was configured with an override that ignores client-directed private directives and applies its own cache policy at the edge tier"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "private requires an accompanying no-store directive in the same header for shared caches to skip storing the response body at all tiers"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "private is honored only on responses to GET requests, so any POST or PATCH route automatically falls back to the CDN's shared cache behavior"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "max-age in seconds overrides any cacheability directive that precedes it, so the CDN applied the 600s TTL across all callers at the shared layer"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "networking.cdn_networking__100003",
   "topic": "networking",
   "subSkill": "cdn_networking",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Comparing a CDN edge server with the application's origin server, which statement best captures their roles?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The edge replaces the origin entirely once cached so the origin can be taken offline without any impact"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The edge generates dynamic responses from scratch while the origin only caches static assets like JS bundles"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The edge terminates client connections close to users and serves cached content; the origin holds the authoritative source"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The edge stores the canonical database while the origin only handles compression and TLS termination for clients"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "networking.cdn_networking__200037",
   "topic": "networking",
   "subSkill": "cdn_networking",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Which statement best describes a tag-based (surrogate-key) purge?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The edge removes all stored responses whose URL path matches a glob pattern supplied by the user"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Operators attach labels to cached objects and invalidate every object sharing a label in one call"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The origin sets a header that downgrades the response so browsers refuse to reuse it next time"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The client emits a Clear-Site-Data directive that wipes its own storage on the next navigation"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "networking.cdn_networking__30550",
   "topic": "networking",
   "subSkill": "cdn_networking",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A company's website is hosted on a single US origin server. After enabling a CDN, average page load time for European users falls from 800ms to 150ms. What is the primary mechanism?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The CDN compresses content more aggressively than the origin server, reducing transfer time"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "The CDN uses a dedicated internet backbone that is faster than the public internet"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "The CDN pre-loads the content onto its European servers before any user requests it, based on its usage predictions"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "The CDN serves the cached copy from a European PoP, so the round trip drops to a few milliseconds"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "networking.cdn_networking__400561",
   "topic": "networking",
   "subSkill": "cdn_networking",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "An edge worker streams a response from origin while also writing it to cache. The origin closes the connection after 5 chunks. What does the worker log?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "async function edge(originRes) {\n  const [a, b] = originRes.body.tee();\n  let n = 0;\n  const reader = b.getReader();\n  while (true) { const { done } = await reader.read(); if (done) break; n++; }\n  console.log(`streamed=${n} chunks, cached=true, status=${originRes.status}`);\n  return new Response(a, { status: originRes.status });\n}\nconst chunks = [1,2,3,4,5];\nconst rs = new ReadableStream({ start(c){ for (const x of chunks) c.enqueue(new Uint8Array([x])); c.close(); } });\nedge(new Response(rs, { status: 200 }));",
    "label": "cdn-networking.ts"
   },
   "widget": {
    "kind": "predict_output",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "streamed=5 chunks, cached=true, status=502"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "streamed=4 chunks, cached=true, status=206"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "streamed=5 chunks, cached=true, status=200"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "streamed=5 chunks, cached=false, status=200"
       }
      ],
      "shape": "code"
     }
    ]
   }
  },
  {
   "questionId": "networking.cdn_networking__1603847",
   "topic": "networking",
   "subSkill": "cdn_networking",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A dev enables Cache-Control: stale-while-revalidate=600 expecting users to see instant stale responses while the CDN refreshes asynchronously. Users still wait for origin on every refresh window. What gotcha did they hit?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "Cache-Control: max-age=60, stale-while-revalidate=600",
    "label": "cdn-networking.ts"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "The CDN tier in question does not implement the SWR directive at the shared layer and treats the response as expired the moment max-age elapses"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "stale-while-revalidate is honored only on responses with status 200 and any redirect or 304 revalidation chain restarts the freshness window for the cached object"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "stale-while-revalidate is interpreted relative to Age rather than max-age, so any object that already had a nonzero Age value at edge ingest disables the directive"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "stale-while-revalidate must be paired with must-revalidate to take effect at shared caches; without it the directive degrades to standard expiration behavior"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "networking.cdn_networking__65482",
   "topic": "networking",
   "subSkill": "cdn_networking",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is anycast routing and how do CDNs use it?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "One address is handed out per region, and the name lookup decides which a reader receives"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "One address is held by a balancer, and it forwards each request on to whichever site is free"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "One address per site is published, and the client tries them in turn until one of them answers"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "One address is announced from many sites, and routing sends each request to the nearest"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "networking.websockets__19699",
   "topic": "networking",
   "subSkill": "websockets",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What problem do ping and pong control frames solve on a long-lived WebSocket link?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Detect dead peers and keep connections alive"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Negotiate payload compression at runtime"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Trigger TLS certificate renegotiation now"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Signal application schema version changes"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.websockets__118273",
   "topic": "networking",
   "subSkill": "websockets",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What does the snippet print to stdout?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "const u = new URL('wss://example.com/socket');\nconsole.log(u.protocol);",
    "label": "websockets.ts"
   },
   "widget": {
    "kind": "predict_output",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "wss:"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "ws::"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "sec:"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "tcp:"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.websockets__19700",
   "topic": "networking",
   "subSkill": "websockets",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Within one WebSocket connection, how are message frames delivered?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Reversed by frame priority tag"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "In order on that connection"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Unordered like UDP datagrams are"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Randomly across all the frames"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.websockets__19701",
   "topic": "networking",
   "subSkill": "websockets",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Compared with Server-Sent Events, what is the single defining capability that WebSocket adds for the same client and server pair?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Client-to-server frames over the same persistent connection"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "A native text/event-stream MIME framing parsed by the browser EventSource API"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Automatic browser-driven reconnection with a Last-Event-ID resume header"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "A built-in retry interval that the server can change at runtime mid-stream"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.websockets__412857",
   "topic": "networking",
   "subSkill": "websockets",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Given Sec-WebSocket-Key 'dGhlIHNhbXBsZSBub25jZQ==', what value does the server echo in Sec-WebSocket-Accept?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "import crypto from 'node:crypto';\nconst key = 'dGhlIHNhbXBsZSBub25jZQ==';\nconst guid = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11';\nconst accept = crypto\n  .createHash('sha1')\n  .update(key + guid)\n  .digest('base64');\nconsole.log(accept);",
    "label": "websockets.ts"
   },
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "s3pPLMBiTxaQ9kYGzzhZRbK+xOo="
       }
      ],
      "shape": "code"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "HSmrc0sMlYUkAGmm5OPpG2HaGWk="
       }
      ],
      "shape": "code"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "rLHCkw/SKsO9GAH/ZSFhBATDKrU="
       }
      ],
      "shape": "code"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "8Q+xMq9oXjL5K0H0w0aZxN3kRdc="
       }
      ],
      "shape": "code"
     }
    ]
   }
  },
  {
   "questionId": "networking.websockets__30532",
   "topic": "networking",
   "subSkill": "websockets",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A financial trading platform requires sub-10ms message delivery via WebSocket. The current p99 is 15ms. Performance analysis shows 8ms is spent in JSON serialization and deserialization. What architectural change addresses this most directly?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Move to a second socket per subscription, so the encoding work is spread across more threads"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Move to compressed text frames, which cut the bytes on the wire and so the delivery time"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Move the encoding onto a worker thread, so the main thread is free while the bytes are built"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Move to binary frames with a compact encoding, which cuts the serialisation time"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.websockets__65392",
   "topic": "networking",
   "subSkill": "websockets",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Why must client-to-server WebSocket frames be masked?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "To give the frame a checksum the receiver uses to spot a corrupted payload"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "To stop a transparent proxy reading the frame as a request and poisoning it"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "To keep the payload private from a proxy that sits between the two endpoints"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "To let the server tell one client's frames apart from another's on one socket"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.websockets__65611",
   "topic": "networking",
   "subSkill": "websockets",
   "difficulty": 1,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What distinguishes WebSocket from the standard HTTP request-response model?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Traffic runs one way at a time, with the two ends taking turns on the connection"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Traffic runs through a proxy that buffers it, so neither end blocks on the other"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Traffic runs over a fresh connection per message, which the runtime pools for you"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Traffic runs both ways at once, so either end can send whenever it has something"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.websockets__65391",
   "topic": "networking",
   "subSkill": "websockets",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What WebSocket opcode represents a text frame?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "0x2"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "0x8"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "0x0"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "0x1"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "networking.websockets__500001",
   "topic": "networking",
   "subSkill": "websockets",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Comparing context-takeover and no-context-takeover modes of permessage-deflate at scale, what is the operator-relevant trade-off?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Context-takeover disables the masking step on client frames, so the server saves CPU at the cost of slightly weaker integrity"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Context-takeover is mandatory when the client sets client_max_window_bits during the handshake's extension negotiation step"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Context-takeover delivers higher throughput by sharing one zlib window across every active connection on the same node"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Context-takeover gives better compression ratios on similar messages but keeps a zlib window resident per connection"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.jwt_security__200418",
   "topic": "crypto_basics",
   "subSkill": "jwt_security",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What does this snippet print?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "const token = 'eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiI0MiIsInJvbGUiOiJhZG1pbiJ9.AbCdEf';\nconst payload = token.split('.')[1];\nconst json = Buffer.from(payload, 'base64url').toString('utf8');\nconsole.log(json);",
    "label": "jwt-security.ts"
   },
   "widget": {
    "kind": "predict_output",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "{\"sub\":\"42\",\"role\":\"user\"}"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "{\"sub\":\"42\",\"role\":\"admin\"}"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "{\"iss\":\"42\",\"role\":\"admin\"}"
       }
      ],
      "shape": "code"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "{\"sub\":42,\"role\":\"admin\"}"
       }
      ],
      "shape": "code"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.jwt_security__839271",
   "topic": "crypto_basics",
   "subSkill": "jwt_security",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "A dev logs out a user by deleting the JWT from localStorage. An attacker who copied the token before logout still gets accepted by the API. Why does logout fail to invalidate the session?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Stateless JWTs require the client to send a logout claim that flips the iat to zero"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Stateless JWTs are valid until exp; revocation needs a server-side denylist or jti tracking"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Stateless JWTs self-revoke at logout; the API stops honouring any token the client discards"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Stateless JWTs need the kid header rotated on logout to invalidate the signing key"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.jwt_security__51076",
   "topic": "crypto_basics",
   "subSkill": "jwt_security",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How does the RS256-to-HS256 key-confusion attack on JWT work, and what prevents it?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "An attacker downgrades alg to HS384 and supplies a colliding HMAC tag of the right length; verifiers comparing tags with naive equality short-circuit on the first byte and accept the value"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "An attacker changes the algorithm from RS256 to HS256 and signs with the RSA public key (which is known). Prevention: validate the algorithm server-side, never trust the token header."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "An attacker keeps alg as RS256 but rewrites the modulus inside the embedded jwk header: verifiers trust the inlined key over the configured public key and accept the forgery without warning"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "An attacker switches alg from RS256 to ES256 and replays the original RSA signature (curve unchecked); verifiers accept the swap whenever the kid header matches a published JWKS entry"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.jwt_security__500659",
   "topic": "crypto_basics",
   "subSkill": "jwt_security",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What does the 'b64' header parameter do under RFC 7797?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "It controls whether the signature covers the payload before or after compression"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "It mandates double base64url to prevent canonicalization attacks between verifiers"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "It selects between standard and url-safe base64 alphabets when serializing claims"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "It allows unencoded payloads while requiring crit to flag the extension explicitly"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.jwt_security__51077",
   "topic": "crypto_basics",
   "subSkill": "jwt_security",
   "difficulty": 2,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Why should sensitive data like passwords or credit card numbers never be stored in a JWT?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Because the JWS compact-serialization rules cap the protected segment at a size that cannot accommodate typical structured credential records or card-data fields"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Because storing credential-grade data in a token violates RFC 7519 section 4, which restricts the payload strictly to registered identity and timing claims"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Because JWT payloads are only Base64url-encoded, not encrypted, making them readable by anyone who intercepts or receives the token"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Because the signature segment overlays the protected payload bytes in a way that prevents downstream consumers from reading individual claim values reliably"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.jwt_security__51092",
   "topic": "crypto_basics",
   "subSkill": "jwt_security",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How should JWT signing be set up in a microservices architecture where many services must verify tokens issued by one auth service?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Distribute the same HS256 secret across every service that needs to verify tokens, and rotate it through configuration management whenever a new service joins the mesh of trusted backends"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Route every protected call through a central token-validation proxy that strips the JWT, verifies the signature against a private key, and reinjects the claims into a trusted header for the backend"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Use asymmetric keys such as RS256 or ES256, so the auth service alone signs with the private key while every other party verifies with the public key and cannot forge tokens"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Have each downstream service issue its own short-lived inner JWT after the outer auth-service token has been verified, so the resource boundary always sees a service-local signature on every call"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.jwt_security__500693",
   "topic": "crypto_basics",
   "subSkill": "jwt_security",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What is the correct characterization of selective disclosure JWTs (SD-JWT) per the IETF draft?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Issuer signs each claim independently so the verifier reassembles the full token directly"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Issuer rotates a per-claim HMAC key so the holder must re-sign the disclosed subset itself"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Issuer salts and hashes individual claims so holders can reveal a chosen subset"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Issuer encrypts each claim with the verifier public key so holders cannot decrypt them"
       }
      ],
      "shape": "long"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.jwt_security__1408273",
   "topic": "crypto_basics",
   "subSkill": "jwt_security",
   "difficulty": 4,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "Per current IETF guidance, replay protection for one-time JWT-style assertions (e.g., client_assertion in OAuth) should rely on which freshness primitive in 2025?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "A unique jti tracked by the verifier within the assertion's exp window"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "A nonce echoed back from a prior unauthenticated server challenge step"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "An iat claim compared against a fixed two-second wall-clock skew"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "A monotonic counter claim that the issuer increments on each new request"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.jwt_security__300617",
   "topic": "crypto_basics",
   "subSkill": "jwt_security",
   "difficulty": 3,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "What does the snippet log?"
      }
     ]
    }
   ],
   "code": {
    "lang": "ts",
    "code": "const jwt = require('jsonwebtoken');\nconst tok = jwt.sign({ sub: 'a' }, 'key-A');\ntry {\n  jwt.verify(tok, 'key-B');\n} catch (e) {\n  console.log(e.name + ': ' + e.message);\n}",
    "label": "jwt-security.ts"
   },
   "widget": {
    "kind": "predict_output",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "JsonWebTokenError: invalid token format"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "JsonWebTokenError: jwt signature missing"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "JsonWebTokenError: jwt malformed value"
       }
      ],
      "shape": "short"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "JsonWebTokenError: invalid signature"
       }
      ],
      "shape": "short"
     }
    ]
   }
  },
  {
   "questionId": "crypto_basics.jwt_security__51101",
   "topic": "crypto_basics",
   "subSkill": "jwt_security",
   "difficulty": 5,
   "stem": [
    {
     "type": "p",
     "runs": [
      {
       "t": "text",
       "v": "How should JWT security evolve to address emerging threats from quantum computing, AI-powered token-theft, and increasingly sophisticated replay techniques?"
      }
     ]
    }
   ],
   "widget": {
    "kind": "mcq",
    "options": [
     {
      "id": "o1",
      "label": [
       {
        "t": "text",
        "v": "Keep the existing RSA and ECDSA suites in place, layer a periodic re-signature step on top of long-lived bearer tokens, and rely on a centralized rate-limiter for theft detection so token shape stays stable across the upgrade window for clients."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o2",
      "label": [
       {
        "t": "text",
        "v": "Replace JWT wholesale with an opaque-only token format issued by a single centralized authorization service (no local checks), drop all client-side validation, and force every protected request through an introspection endpoint (per call) whatever the latency cost"
       }
      ],
      "shape": "long"
     },
     {
      "id": "o3",
      "label": [
       {
        "t": "text",
        "v": "Treat quantum risk as the only threat that matters, swap the signing primitive to a single post-quantum scheme, and leave token storage, replay defense, and authorization-freshness mechanisms untouched since the cryptographic core dominates every other dimension of risk."
       }
      ],
      "shape": "long"
     },
     {
      "id": "o4",
      "label": [
       {
        "t": "text",
        "v": "Move signing to a post-quantum algorithm (ML-DSA), add behavioral analysis for anomalous token usage, bind tokens to hardware (DPoP, token binding) so a stolen token is useless, and adopt zero-trust continuous authorization beyond the initial JWT check."
       }
      ],
      "shape": "long"
     }
    ]
   }
  }
 ]
}