java.lang.Object
net.i2p.crypto.SessionKeyManager
net.i2p.router.crypto.ratchet.MuxedPQSKM
public class MuxedPQSKMextends SessionKeyManager
Post-quantum hybrid session key manager combining ECIES and ML-KEM operations.

  • Field Details

    • _ec

      private final RatchetSKM _ec
      The ratcheted ECIES session keys.

    • _pq

      private final RatchetSKM _pq
      The ratcheted post-quantum session keys.

    • _ecCounter

      private final AtomicInteger _ecCounter
      Counts the ECIES keys handed out.

    • _pqCounter

      private final AtomicInteger _pqCounter
      Counts the post-quantum keys handed out.

    • _log

      private final Log _log
      Logger for this class.

    • PQ_SLOW_FACTOR

      static final int PQ_SLOW_FACTOR
      How much slower the PQ slow decrypt is than the ratchet one, so its success count is divided by this much before the two are compared.
      See Also:

    • RESTART_COUNTERS

      static final int RESTART_COUNTERS
      Size of the sampling window. Once both counters are individually meaningful and their sum passes this, the window rolls over so the ordering tracks recent traffic instead of the whole session.
      See Also:

  • Constructor Details

    • MuxedPQSKM

      public MuxedPQSKM(RatchetSKM ec, RatchetSKM pq)
      Combines ECIES and PQ SKMs with adaptive decrypt ordering.
      Parameters:
      ec - the ECIES ratchet key manager
      pq - the post-quantum ratchet key manager

  • Method Details

    • getECSKM

      public RatchetSKM getECSKM()
      The ECIES ratchet key manager combined into this hybrid.
      Returns:
      the ECIES ratchet key manager

    • getPQSKM

      public RatchetSKM getPQSKM()
      The post-quantum ratchet key manager combined into this hybrid.
      Returns:
      the post-quantum ratchet key manager

    • preferRatchet

      boolean preferRatchet()
      Should we try the Ratchet slow decrypt before PQ slow decrypt? Adaptive test based on previous mix of traffic for this SKM, as reported by reportDecryptResult().
      Returns:
      true if the Ratchet decrypt is tried first, false for PQ

    • preferRatchetNow

      boolean preferRatchetNow()
      The ordering the current window favours, without rolling the sampling window over. Reporting has to use this rather than preferRatchet(): a log line that resets the counters changes which decrypt the next message tries first, and the value it prints is not the one that decision used.
      Returns:
      true if the Ratchet decrypt would be tried first right now

    • needsRestart

      static boolean needsRestart(int ec, int pq)
      Whether the sampling window is full and both counters should start over, so the ordering tracks recent traffic rather than the whole session.
      Parameters:
      ec - successful ratchet decrypts in the current window
      pq - successful PQ decrypts in the current window
      Returns:
      true if the window has run its course

    • preferRatchet

      static boolean preferRatchet(int ec, int pq)
      The ordering the current window favours, with the PQ count discounted because the ratchet slow decrypt is the cheaper of the two to try first.
      Parameters:
      ec - successful ratchet decrypts in the current window
      pq - successful PQ decrypts in the current window
      Returns:
      true if the ratchet slow decrypt should go first

    • rollOver

      static boolean rollOver(AtomicInteger counter, int expected)
      Reset one counter to start a fresh window, only if nothing was recorded since the value the decision was taken on. A plain set(0) would discard any success logged between that read and the reset, which is how the counters used to lose counts under concurrent decrypts.
      Parameters:
      counter - the counter to roll over
      expected - the value read when the decision was taken
      Returns:
      true if the counter was reset, false if it moved in the meantime

    • reportDecryptResult

      void reportDecryptResult(boolean isRatchet, boolean success)
      Report the result of a slow decrypt attempt.
      Parameters:
      isRatchet - true for EC, false for PQ
      success - true for successful decrypt

    • getCurrentKey

      public SessionKey getCurrentKey(PublicKey target)
      ElG only.
      Overrides:
      getCurrentKey in class SessionKeyManager
      Parameters:
      target - the destination whose current session key is wanted
      Returns:
      the current key

    • getCurrentOrNewKey

      public SessionKey getCurrentOrNewKey(PublicKey target)
      ElG only.
      Overrides:
      getCurrentOrNewKey in class SessionKeyManager
      Parameters:
      target - the destination to start or continue a session with
      Returns:
      the current or new key

    • createSession

      public void createSession(PublicKey target, SessionKey key)
      ElG only.
      Overrides:
      createSession in class SessionKeyManager
      Parameters:
      target - the destination the session is established with
      key - the session key to associate, whose expiry metrics start at this call

    • createSession

      public SessionKey createSession(PublicKey target)
      ElG only.
      Overrides:
      createSession in class SessionKeyManager
      Parameters:
      target - the destination to establish a freshly generated session with
      Returns:
      the session key

    • consumeNextAvailableTag

      public SessionTag consumeNextAvailableTag(PublicKey target, SessionKey key)
      ElG only.
      Overrides:
      consumeNextAvailableTag in class SessionKeyManager
      Parameters:
      target - the destination the tag was sent to
      key - the session key whose use the tag identifies
      Returns:
      the next available tag, or null

    • consumeNextAvailableTag

      public RatchetEntry consumeNextAvailableTag(PublicKey target)
      EC/PQ.
      Parameters:
      target - the target peer's ephemeral key; its type picks the SKM
      Returns:
      the next available tag, or null

    • getTagsToSend

      public int getTagsToSend()
      Not used; tag management is handled by the ratchet protocol.
      Overrides:
      getTagsToSend in class SessionKeyManager
      Returns:
      0, tag management is handled by ratchet protocol

    • getLowThreshold

      public int getLowThreshold()
      Not used; thresholds are not used for ratchet sessions.
      Overrides:
      getLowThreshold in class SessionKeyManager
      Returns:
      0, threshold not used for ratchet sessions

    • shouldSendTags

      public boolean shouldSendTags(PublicKey target, SessionKey key)
      ElG only.
      Overrides:
      shouldSendTags in class SessionKeyManager
      Parameters:
      target - the destination whose tags are being considered
      key - the session key
      Returns:
      whether send tags

    • shouldSendTags

      public boolean shouldSendTags(PublicKey target, SessionKey key, int lowThreshold)
      ElG only.
      Overrides:
      shouldSendTags in class SessionKeyManager
      Parameters:
      target - the destination whose tags are being considered
      key - the session key
      lowThreshold - the low threshold
      Returns:
      whether send tags

    • getAvailableTags

      public int getAvailableTags(PublicKey target, SessionKey key)
      Delegates to the appropriate key manager by encryption type.
      Overrides:
      getAvailableTags in class SessionKeyManager
      Parameters:
      target - the destination the tags were sent to
      key - the session key those tags were issued under
      Returns:
      the available tags

    • getAvailableTimeLeft

      public long getAvailableTimeLeft(PublicKey target, SessionKey key)
      Delegates to the appropriate key manager by encryption type.
      Overrides:
      getAvailableTimeLeft in class SessionKeyManager
      Parameters:
      target - the destination the tags were sent to
      key - the session key those tags were issued under
      Returns:
      the available time left

    • tagsDelivered

      public TagSetHandle tagsDelivered(PublicKey target, SessionKey key, Set<SessionTag> sessionTags)
      ElG only.
      Overrides:
      tagsDelivered in class SessionKeyManager
      Parameters:
      target - the destination that acknowledged the tags
      key - the session key the acknowledged tags were issued under
      sessionTags - modifiable; NOT copied
      Returns:
      the tag set handle

    • tagsReceived

      public void tagsReceived(SessionKey key, Set<SessionTag> sessionTags)
      ElG only.
      Overrides:
      tagsReceived in class SessionKeyManager
      Parameters:
      key - the session key the tags were received for
      sessionTags - modifiable; NOT copied

    • tagsReceived

      public void tagsReceived(SessionKey key, Set<SessionTag> sessionTags, long expire)
      ElG only.
      Overrides:
      tagsReceived in class SessionKeyManager
      Parameters:
      key - the session key the tags were received for
      sessionTags - modifiable; NOT copied
      expire - time from now

    • tagsReceived

      public void tagsReceived(SessionKey key, RatchetSessionTag tag, long expire)
      EC only. One time session We do not support PQ one-time sessions on MuxedPQSKM.
      Parameters:
      key - the session key the tag was received under
      tag - the ratchet session tag to store for the session
      expire - time from now

    • consumeTag

      public SessionKey consumeTag(SessionTag tag)
      Tries ECIES tag lookup first, falls back to PQ lookup.
      Overrides:
      consumeTag in class SessionKeyManager
      Parameters:
      tag - the session tag whose delivered key is consumed
      Returns:
      the session key, or null

    • shutdown

      public void shutdown()
      Shuts down both ECIES and PQ key managers.
      Overrides:
      shutdown in class SessionKeyManager

    • renderStatusHTML

      public void renderStatusHTML(Writer out) throws IOException
      Renders debug status for both key managers.
      Overrides:
      renderStatusHTML in class SessionKeyManager
      Parameters:
      out - the writer to render to
      Throws:
      IOException - if an I/O error occurs

    • getDebugStats

      public long[] getDebugStats()
      Sums the debug stats of both key managers, null if neither tracks them.
      Overrides:
      getDebugStats in class SessionKeyManager
      Returns:
      the stats, or null

    • failTags

      public void failTags(PublicKey target, SessionKey key, TagSetHandle ts)
      ElG only.
      Overrides:
      failTags in class SessionKeyManager
      Parameters:
      target - the destination whose tags are being considered
      key - the session key
      ts - the tag set handle

    • tagsAcked

      public void tagsAcked(PublicKey target, SessionKey key, TagSetHandle ts)
      ElG only.
      Overrides:
      tagsAcked in class SessionKeyManager
      Parameters:
      target - the destination whose tags are being considered
      key - the session key
      ts - the tag set handle