org.jivesoftware.smackx.omemo.util

Class OmemoKeyUtil<T_IdKeyPair,T_IdKey,T_PreKey,T_SigPreKey,T_Sess,T_Addr,T_ECPub,T_Bundle,T_Ciph>

java.lang.Object

org.jivesoftware.smackx.omemo.util.OmemoKeyUtil<T_IdKeyPair,T_IdKey,T_PreKey,T_SigPreKey,T_Sess,T_Addr,T_ECPub,T_Bundle,T_Ciph>

Type Parameters:

T_IdKeyPair - IdentityKeyPair class

T_IdKey - IdentityKey class

T_PreKey - PreKey class

T_SigPreKey - SignedPreKey class

T_Sess - Session class

T_Addr - Address class

T_ECPub - Elliptic Curve PublicKey class

T_Bundle - Bundle class

T_Ciph - Cipher class

Direct Known Subclasses:

SignalOmemoKeyUtil

public abstract class OmemoKeyUtil<T_IdKeyPair,T_IdKey,T_PreKey,T_SigPreKey,T_Sess,T_Addr,T_ECPub,T_Bundle,T_Ciph>
extends java.lang.Object

Class that is used to convert bytes to keys and vice versa.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
class	OmemoKeyUtil.Bundle Bundle related methods.

Field Summary

Fields

Modifier and Type	Field and Description
OmemoKeyUtil.Bundle	BUNDLE

Constructor Summary

Constructors

Constructor and Description
OmemoKeyUtil()

Method Summary

Modifier and Type	Method and Description
static int	addInBounds(int value, int added) Add integers modulo MAX_VALUE.
abstract OmemoDevice	addressAsOmemoDevice(T_Addr address) Convert a crypto-lib specific contact object into an OmemoDevice.
abstract T_Bundle	bundleFromOmemoBundle(OmemoBundleVAxolotlElement bundle, OmemoDevice contact, int keyId) Build a crypto-lib specific PreKeyBundle (T_Bundle) using a PreKey from the OmemoBundleElement 'bundle'.
abstract OmemoSession<T_IdKeyPair,T_IdKey,T_PreKey,T_SigPreKey,T_Sess,T_Addr,T_ECPub,T_Bundle,T_Ciph>	createOmemoSession(OmemoManager omemoManager, OmemoStore<T_IdKeyPair,T_IdKey,T_PreKey,T_SigPreKey,T_Sess,T_Addr,T_ECPub,T_Bundle,T_Ciph> omemoStore, OmemoDevice from) Create a new crypto-specific Session object.
abstract OmemoSession<T_IdKeyPair,T_IdKey,T_PreKey,T_SigPreKey,T_Sess,T_Addr,T_ECPub,T_Bundle,T_Ciph>	createOmemoSession(OmemoManager omemoManager, OmemoStore<T_IdKeyPair,T_IdKey,T_PreKey,T_SigPreKey,T_Sess,T_Addr,T_ECPub,T_Bundle,T_Ciph> omemoStore, OmemoDevice device, T_IdKey identityKey) Create a new concrete OmemoSession with a contact.
abstract T_ECPub	ellipticCurvePublicKeyFromBytes(byte[] data) Deserialize an elliptic curve public key from bytes.
abstract T_IdKeyPair	generateOmemoIdentityKeyPair() Generate a new IdentityKeyPair.
abstract java.util.HashMap<java.lang.Integer,T_PreKey>	generateOmemoPreKeys(int startId, int count) Generate 'count' new PreKeys beginning with id 'startId'.
abstract T_SigPreKey	generateOmemoSignedPreKey(T_IdKeyPair identityKeyPair, int signedPreKeyId) Generate a new signed preKey.
abstract OmemoFingerprint	getFingerprint(T_IdKey identityKey) Return the fingerprint of an identityKey.
abstract byte[]	identityKeyForBundle(T_IdKey identityKey) Prepare an identityKey for transport in an OmemoBundleElement (serialize it).
abstract T_IdKey	identityKeyFromBytes(byte[] data) Deserialize an identityKey from a byte array.
abstract T_IdKey	identityKeyFromPair(T_IdKeyPair pair) Extract the public identityKey from an identityKeyPair.
abstract T_IdKeyPair	identityKeyPairFromBytes(byte[] data) Deserialize an identityKeyPair from a byte array.
abstract byte[]	identityKeyPairToBytes(T_IdKeyPair identityKeyPair) serialize an identityKeyPair into bytes.
abstract byte[]	identityKeyToBytes(T_IdKey identityKey) Serialize an identityKey into bytes.
abstract T_Addr	omemoDeviceAsAddress(OmemoDevice contact) Convert an OmemoDevice to a crypto-lib specific contact format.
abstract byte[]	preKeyForBundle(T_PreKey preKey) Prepare a preKey for transport in an OmemoBundleElement.
abstract T_PreKey	preKeyFromBytes(byte[] bytes) Deserialize a preKey from a byte array.
T_ECPub	preKeyPublicFromBytes(byte[] data) Deserialize a public preKey from bytes.
abstract byte[]	preKeyPublicKeyForBundle(T_ECPub preKey) Prepare an elliptic curve preKey for transport in an OmemoBundleElement.
java.util.HashMap<java.lang.Integer,byte[]>	preKeyPublisKeysForBundle(java.util.HashMap<java.lang.Integer,T_PreKey> preKeyHashMap) Prepare a whole bunche of preKeys for transport.
abstract byte[]	preKeyToBytes(T_PreKey preKey) Serialize a preKey into a byte array.
static java.lang.String	prettyFingerprint(OmemoFingerprint fingerprint)
static java.lang.String	prettyFingerprint(java.lang.String ugly) Split the fingerprint in blocks of 8 characters with spaces between.
abstract T_Sess	rawSessionFromBytes(byte[] data) Deserialize a raw OMEMO Session from bytes.
abstract byte[]	rawSessionToBytes(T_Sess session) Serialize a raw OMEMO session into a byte array.
abstract T_SigPreKey	signedPreKeyFromBytes(byte[] data) Deserialize a signedPreKey from a byte array.
abstract int	signedPreKeyIdFromKey(T_SigPreKey signedPreKey) return the id of the given signedPreKey.
abstract byte[]	signedPreKeyPublicForBundle(T_SigPreKey signedPreKey) Prepare a public signedPreKey for transport in a bundle.
T_ECPub	signedPreKeyPublicFromBytes(byte[] data) Deserialize a public signedPreKey from bytes.
abstract byte[]	signedPreKeySignatureFromKey(T_SigPreKey signedPreKey) Extract the signature from a signedPreKey.
abstract byte[]	signedPreKeyToBytes(T_SigPreKey sigPreKey) Serialize a signedPreKey into a byte array.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

BUNDLE

public final OmemoKeyUtil.Bundle BUNDLE

Constructor Detail

OmemoKeyUtil

public OmemoKeyUtil()

Method Detail

identityKeyPairFromBytes

public abstract T_IdKeyPair identityKeyPairFromBytes(byte[] data)
                                              throws CorruptedOmemoKeyException

Deserialize an identityKeyPair from a byte array.

Parameters:

data - byte array

Returns:

IdentityKeyPair (T_IdKeyPair)

Throws:

CorruptedOmemoKeyException - if the key is damaged of malformed

identityKeyFromBytes

public abstract T_IdKey identityKeyFromBytes(byte[] data)
                                      throws CorruptedOmemoKeyException

Deserialize an identityKey from a byte array.

Parameters:

data - byte array

Returns:

identityKey (T_IdKey)

Throws:

CorruptedOmemoKeyException - if the key is damaged or malformed

identityKeyToBytes

public abstract byte[] identityKeyToBytes(T_IdKey identityKey)

Serialize an identityKey into bytes.

Parameters:

identityKey - idKey

Returns:

bytes

ellipticCurvePublicKeyFromBytes

public abstract T_ECPub ellipticCurvePublicKeyFromBytes(byte[] data)
                                                 throws CorruptedOmemoKeyException

Deserialize an elliptic curve public key from bytes.

Parameters:

data - bytes

Returns:

elliptic curve public key (T_ECPub)

Throws:

CorruptedOmemoKeyException - if the key is damaged or malformed

preKeyPublicFromBytes

public T_ECPub preKeyPublicFromBytes(byte[] data)
                              throws CorruptedOmemoKeyException

Deserialize a public preKey from bytes.

Parameters:

data - preKey as bytes

Returns:

preKey

Throws:

CorruptedOmemoKeyException - if the key is damaged or malformed

preKeyToBytes

public abstract byte[] preKeyToBytes(T_PreKey preKey)

Serialize a preKey into a byte array.

Parameters:

preKey - preKey

Returns:

byte[]

preKeyFromBytes

public abstract T_PreKey preKeyFromBytes(byte[] bytes)
                                  throws java.io.IOException

Deserialize a preKey from a byte array.

Parameters:

bytes - byte array

Returns:

deserialized preKey

Throws:

java.io.IOException - when something goes wrong

generateOmemoPreKeys

public abstract java.util.HashMap<java.lang.Integer,T_PreKey> generateOmemoPreKeys(int startId,
                                                                                   int count)

Generate 'count' new PreKeys beginning with id 'startId'. These preKeys are published and can be used by contacts to establish sessions with us.

Parameters:

startId - start id

count - how many keys do we want to generate

Returns:

Map of new preKeys

generateOmemoSignedPreKey

public abstract T_SigPreKey generateOmemoSignedPreKey(T_IdKeyPair identityKeyPair,
                                                      int signedPreKeyId)
                                               throws CorruptedOmemoKeyException

Generate a new signed preKey.

Parameters:

identityKeyPair - identityKeyPair used to sign the preKey

signedPreKeyId - id that the preKey will have

Returns:

signedPreKey

Throws:

CorruptedOmemoKeyException - when the identityKeyPair is invalid

signedPreKeyPublicFromBytes

public T_ECPub signedPreKeyPublicFromBytes(byte[] data)
                                    throws CorruptedOmemoKeyException

Deserialize a public signedPreKey from bytes.

Parameters:

data - bytes

Returns:

signedPreKey

Throws:

CorruptedOmemoKeyException - if the key is damaged or malformed

signedPreKeyFromBytes

public abstract T_SigPreKey signedPreKeyFromBytes(byte[] data)
                                           throws java.io.IOException

Deserialize a signedPreKey from a byte array.

Parameters:

data - byte array

Returns:

deserialized signed preKey

Throws:

java.io.IOException - when something goes wrong

signedPreKeyToBytes

public abstract byte[] signedPreKeyToBytes(T_SigPreKey sigPreKey)

Serialize a signedPreKey into a byte array.

Parameters:

sigPreKey - signedPreKey

Returns:

byte array

bundleFromOmemoBundle

public abstract T_Bundle bundleFromOmemoBundle(OmemoBundleVAxolotlElement bundle,
                                               OmemoDevice contact,
                                               int keyId)
                                        throws CorruptedOmemoKeyException

Build a crypto-lib specific PreKeyBundle (T_Bundle) using a PreKey from the OmemoBundleElement 'bundle'. The PreKeyBundle will contain the identityKey, signedPreKey and signature, as well as a preKey from the OmemoBundleElement.

Parameters:

bundle - OmemoBundleElement

contact - Contact that the bundle belongs to

keyId - id of the preKey that will be selected from the OmemoBundleElement and that the PreKeyBundle will contain

Returns:

PreKeyBundle (T_PreKey)

Throws:

CorruptedOmemoKeyException - if some key is damaged or malformed

signedPreKeySignatureFromKey

public abstract byte[] signedPreKeySignatureFromKey(T_SigPreKey signedPreKey)

Extract the signature from a signedPreKey.

Parameters:

signedPreKey - signedPreKey

Returns:

signature as byte array

generateOmemoIdentityKeyPair

public abstract T_IdKeyPair generateOmemoIdentityKeyPair()

Generate a new IdentityKeyPair. We should always have only one pair and usually keep this for a long time.

Returns:

identityKeyPair

signedPreKeyIdFromKey

public abstract int signedPreKeyIdFromKey(T_SigPreKey signedPreKey)

return the id of the given signedPreKey.

Parameters:

signedPreKey - key

Returns:

id of the key

identityKeyPairToBytes

public abstract byte[] identityKeyPairToBytes(T_IdKeyPair identityKeyPair)

serialize an identityKeyPair into bytes.

Parameters:

identityKeyPair - identityKeyPair

Returns:

byte array

identityKeyFromPair

public abstract T_IdKey identityKeyFromPair(T_IdKeyPair pair)

Extract the public identityKey from an identityKeyPair.

Parameters:

pair - keyPair

Returns:

public key of the pair

identityKeyForBundle

public abstract byte[] identityKeyForBundle(T_IdKey identityKey)

Prepare an identityKey for transport in an OmemoBundleElement (serialize it).

Parameters:

identityKey - identityKey that will be transported

Returns:

key as byte array

preKeyPublicKeyForBundle

public abstract byte[] preKeyPublicKeyForBundle(T_ECPub preKey)

Prepare an elliptic curve preKey for transport in an OmemoBundleElement.

Parameters:

preKey - key

Returns:

key as byte array

preKeyForBundle

public abstract byte[] preKeyForBundle(T_PreKey preKey)

Prepare a preKey for transport in an OmemoBundleElement.

Parameters:

preKey - preKey

Returns:

key as byte array

preKeyPublisKeysForBundle

public java.util.HashMap<java.lang.Integer,byte[]> preKeyPublisKeysForBundle(java.util.HashMap<java.lang.Integer,T_PreKey> preKeyHashMap)

Prepare a whole bunche of preKeys for transport.

Parameters:

preKeyHashMap - HashMap of preKeys

Returns:

HashMap of byte arrays but with the same keyIds as key

signedPreKeyPublicForBundle

public abstract byte[] signedPreKeyPublicForBundle(T_SigPreKey signedPreKey)

Prepare a public signedPreKey for transport in a bundle.

Parameters:

signedPreKey - signedPrekey

Returns:

signedPreKey as byte array

getFingerprint

public abstract OmemoFingerprint getFingerprint(T_IdKey identityKey)

Return the fingerprint of an identityKey.

Parameters:

identityKey - identityKey

Returns:

fingerprint of the key

createOmemoSession

public abstract OmemoSession<T_IdKeyPair,T_IdKey,T_PreKey,T_SigPreKey,T_Sess,T_Addr,T_ECPub,T_Bundle,T_Ciph> createOmemoSession(OmemoManager omemoManager,
                                                                                                                                OmemoStore<T_IdKeyPair,T_IdKey,T_PreKey,T_SigPreKey,T_Sess,T_Addr,T_ECPub,T_Bundle,T_Ciph> omemoStore,
                                                                                                                                OmemoDevice from)

Create a new crypto-specific Session object.

Parameters:

omemoManager - omemoManager of our device.

omemoStore - omemoStore where we can save the session, get keys from etc.

from - the device we want to create the session with.

Returns:

a new session

createOmemoSession

public abstract OmemoSession<T_IdKeyPair,T_IdKey,T_PreKey,T_SigPreKey,T_Sess,T_Addr,T_ECPub,T_Bundle,T_Ciph> createOmemoSession(OmemoManager omemoManager,
                                                                                                                                OmemoStore<T_IdKeyPair,T_IdKey,T_PreKey,T_SigPreKey,T_Sess,T_Addr,T_ECPub,T_Bundle,T_Ciph> omemoStore,
                                                                                                                                OmemoDevice device,
                                                                                                                                T_IdKey identityKey)

Create a new concrete OmemoSession with a contact.

Parameters:

omemoManager - omemoManager of our device.

omemoStore - omemoStore

device - device to establish the session with

identityKey - identityKey of the device

Returns:

concrete OmemoSession

rawSessionFromBytes

public abstract T_Sess rawSessionFromBytes(byte[] data)
                                    throws java.io.IOException

Deserialize a raw OMEMO Session from bytes.

Parameters:

data - bytes

Returns:

raw OMEMO Session

Throws:

java.io.IOException - when something goes wrong

rawSessionToBytes

public abstract byte[] rawSessionToBytes(T_Sess session)

Serialize a raw OMEMO session into a byte array.

Parameters:

session - raw session

Returns:

byte array

omemoDeviceAsAddress

public abstract T_Addr omemoDeviceAsAddress(OmemoDevice contact)

Convert an OmemoDevice to a crypto-lib specific contact format.

Parameters:

contact - omemoContact

Returns:

crypto-lib specific contact object

addressAsOmemoDevice

public abstract OmemoDevice addressAsOmemoDevice(T_Addr address)
                                          throws org.jxmpp.stringprep.XmppStringprepException

Convert a crypto-lib specific contact object into an OmemoDevice.

Parameters:

address - contact

Returns:

as OmemoDevice

Throws:

org.jxmpp.stringprep.XmppStringprepException - if the address is not a valid BareJid

prettyFingerprint

public static java.lang.String prettyFingerprint(OmemoFingerprint fingerprint)

prettyFingerprint

public static java.lang.String prettyFingerprint(java.lang.String ugly)

Split the fingerprint in blocks of 8 characters with spaces between.

Parameters:

ugly - fingerprint as continuous string

Returns:

fingerprint with spaces for better readability

addInBounds

public static int addInBounds(int value,
                              int added)

Add integers modulo MAX_VALUE.

Parameters:

value - base integer

added - value that is added to the base value

Returns:

(value plus added) modulo Integer.MAX_VALUE