package net.i2p.crypto;
/*
* free (adj.): unencumbered; not under the control of others
* Written by jrandom in 2003 and released into the public domain
* with no warranty of any kind, either expressed or implied.
* It probably won't make your computer catch on fire, or eat
* your children, but it might. Use at your own risk.
*
*/
import java.io.IOException;
import java.io.Writer;
import java.util.Set;
import net.i2p.I2PAppContext;
import net.i2p.data.PublicKey;
import net.i2p.data.SessionKey;
import net.i2p.data.SessionTag;
/**
* Manage the session keys and session tags used for encryption and decryption.
* This base implementation simply ignores sessions and acts as if everything is
* unknown (and hence always forces a full ElGamal encryption for each message).
* See TransientSessionKeyManager subclass which manages and persists keys and tags.
*
*/
public class SessionKeyManager {
/**
* A dummy SessionKeyManager for testing or for passing to
* ElGamalAESEngine.decrypt()
*
* @since 0.9.14
*/
public SessionKeyManager() {}
/**
* A dummy SessionKeyManager for testing or for passing to
* ElGamalAESEngine.decrypt()
*
* @param context unused
* @since public since 0.9.14; protected before that
*/
public SessionKeyManager(I2PAppContext context) {}
/**
* Retrieve the session key currently associated with encryption to the target,
* or null if a new session key should be generated.
*
* Warning - don't generate a new session if this returns null, it's racy, use getCurrentOrNewKey()
*/
public SessionKey getCurrentKey(PublicKey target) {
return null;
}
/**
* Retrieve the session key currently associated with encryption to the target.
* Generates a new session and session key if not previously exising.
*
* @return non-null
* @since 0.9
*/
public SessionKey getCurrentOrNewKey(PublicKey target) {
return null;
}
/**
* Associate a new session key with the specified target. Metrics to determine
* when to expire that key begin with this call.
*
* Racy if called after getCurrentKey() to check for a current session;
* use getCurrentOrNewKey() in that case.
*/
public void createSession(PublicKey target, SessionKey key) { // nop
}
/**
* Generate a new session key and associate it with the specified target.
*
* Racy if called after getCurrentKey() to check for a current session;
* use getCurrentOrNewKey() in that case.
*/
public SessionKey createSession(PublicKey target) {
SessionKey key = KeyGenerator.getInstance().generateSessionKey();
createSession(target, key);
return key;
}
/**
* Retrieve the next available session tag for identifying the use of the given
* key when communicating with the target. If this returns null, no tags are
* available so ElG should be used with the given key (a new sessionKey should
* NOT be used)
*
*/
public SessionTag consumeNextAvailableTag(PublicKey target, SessionKey key) {
return null;
}
/**
* How many to send, IF we need to.
* @since 0.9.2
*/
public int getTagsToSend() { return 0; };
/**
* @since 0.9.2
*/
public int getLowThreshold() { return 0; };
/**
* @return true if we have less than the threshold or what we have is about to expire
* @since 0.9.2
*/
public boolean shouldSendTags(PublicKey target, SessionKey key) {
return shouldSendTags(target, key, getLowThreshold());
}
/**
* @return true if we have less than the threshold or what we have is about to expire
* @since 0.9.2
*/
public boolean shouldSendTags(PublicKey target, SessionKey key, int lowThreshold) { return false; }
/**
* Determine (approximately) how many available session tags for the current target
* have been confirmed and are available
*
*/
public int getAvailableTags(PublicKey target, SessionKey key) {
return 0;
}
/**
* Determine how long the available tags will be available for before expiring, in
* milliseconds
*/
public long getAvailableTimeLeft(PublicKey target, SessionKey key) {
return 0;
}
/**
* Take note of the fact that the given sessionTags associated with the key for
* encryption to the target have definitely been received at the target (aka call this
* method after receiving an ack to a message delivering them)
*
*/
public TagSetHandle tagsDelivered(PublicKey target, SessionKey key, Set<SessionTag> sessionTags) { // nop
return null;
}
/**
* Mark all of the tags delivered to the target up to this point as invalid, since the peer
* has failed to respond when they should have. This call essentially lets the system recover
* from corrupted tag sets and crashes
*
*/
public void failTags(PublicKey target) { // nop
}
/**
* Accept the given tags and associate them with the given key for decryption,
* with the default expiration.
*/
public void tagsReceived(SessionKey key, Set<SessionTag> sessionTags) {}
/**
* Accept the given tags and associate them with the given key for decryption,
* with specified expiration.
*
* @param sessionTags modifiable; NOT copied
* @param expire time from now
* @since 0.9.7
*/
public void tagsReceived(SessionKey key, Set<SessionTag> sessionTags, long expire) {}
/**
* Determine if we have received a session key associated with the given session tag,
* and if so, discard it (but keep track for frequent dups) and return the decryption
* key it was received with (via tagsReceived(...)). returns null if no session key
* matches
*
*/
public SessionKey consumeTag(SessionTag tag) {
return null;
}
/**
* Called when the system is closing down, instructing the session key manager to take
* whatever precautions are necessary (saving state, etc)
*
*/
public void shutdown() { // nop
}
public void renderStatusHTML(Writer out) throws IOException {}
public void failTags(PublicKey target, SessionKey key, TagSetHandle ts) {}
public void tagsAcked(PublicKey target, SessionKey key, TagSetHandle ts) {}
}