org.linguafranca.pwdb.kdbx

Class KdbxHeader

java.lang.Object

org.linguafranca.pwdb.kdbx.KdbxHeader

All Implemented Interfaces:

StreamConfiguration

public class KdbxHeader
extends Object
implements StreamConfiguration

This class represents the header portion of a KeePass KDBX file or stream. The header is received in plain text and describes the encryption and compression of the remainder of the file.

In V4 the header became Outer Header and Inner Header. The class stores the configuration contents of both and binary attachments.

It is a factory for encryption and decryption streams. It provides for verification of its own serialization.

While KDBX streams are Little-Endian, data is passed to and from this class in standard Java byte order.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	KdbxHeader.CompressionFlags The ordinal 0 represents uncompressed and 1 GZip compressed

Nested classes/interfaces inherited from interface org.linguafranca.pwdb.StreamConfiguration

StreamConfiguration.None

Field Summary

Fields

Modifier and Type	Field and Description
protected UUID	cipherUuid
static SecureRandom	random

Constructor Summary

Constructors

Constructor and Description
KdbxHeader() Construct a default version 3 KDBX header
KdbxHeader(int version) Construct a default KDBX header with AES/AES/SALSA_20
KdbxHeader(org.linguafranca.pwdb.kdbx.KdbxHeader.KdbxHeaderOptions opts)

Method Summary

Modifier and Type	Method and Description
void	addBinary(byte[] bytes) V4 add binary from inner header
InputStream	createDecryptedStream(byte[] digest, InputStream inputStream) Create a decrypted input stream using supplied digest and this header apply decryption to the passed encrypted input stream
OutputStream	createEncryptedStream(byte[] digest, OutputStream outputStream) Create an unencrypted outputStream using the supplied digest and this header and use the supplied output stream to write encrypted data.
List<byte[]>	getBinaries()
CipherAlgorithm	getCipherAlgorithm()
UUID	getCipherUuid()
KdbxHeader.CompressionFlags	getCompressionFlags()
byte[]	getEncryptionIv()
byte[]	getHeaderBytes() V4 provide access to the header as bytes for verification
byte[]	getHeaderHash()
byte[]	getHmacKey(Credentials credentials) Compute the Hmac Key Digest from "KdbxFile.cs Computekeys"
byte[]	getInnerRandomStreamKey()
StreamEncryptor	getInnerStreamEncryptor()
VariantDictionary	getKdfParameters()
KeyDerivationFunction	getKeyDerivationFunction()
byte[]	getMasterSeed()
Encryption.ProtectedStreamAlgorithm	getProtectedStreamAlgorithm()
StreamEncryptor	getStreamEncryptor()
byte[]	getStreamStartBytes()
byte[]	getTransformedKeyDigest(byte[] digest) Takes the composite credentials and transforms them according to the underlying KDF algorithm.
long	getTransformRounds()
byte[]	getTransformSeed()
int	getVersion()
void	setCipherAlgorithm(CipherAlgorithm cipherAlgorithm)
void	setCipherUuid(byte[] uuid)
void	setCipherUuid(UUID uuid)
void	setCompressionFlags(int flags)
void	setCustomData(VariantDictionary customData) V4 Add custom data
void	setEncryptionIv(byte[] encryptionIv)
void	setHeaderBytes(byte[] headerBytes) V4 provide access to the header as bytes for verification
void	setHeaderHash(byte[] headerHash)
void	setInnerRandomStreamId(int innerRandomStreamId)
void	setInnerRandomStreamKey(byte[] key)
void	setKdfParameters(VariantDictionary kdfParameters) V4 add Key Definition Function Parameters
void	setKeyDerivationFunction(KeyDerivationFunction keyDerivationFunction)
void	setMasterSeed(byte[] masterSeed)
void	setProtectedStreamAlgorithm(Encryption.ProtectedStreamAlgorithm protectedStreamAlgorithm)
void	setStreamStartBytes(byte[] streamStartBytes)
void	setTransformRounds(long transformRounds)
void	setTransformSeed(byte[] transformSeed)
void	setVersion(int version)
void	verifyHeaderHmac(byte[] key, byte[] bytes) Verify the header Hmac

Methods inherited from class java.lang.Object

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

Field Detail

cipherUuid

protected UUID cipherUuid

random

public static SecureRandom random

Constructor Detail

KdbxHeader

public KdbxHeader()

Construct a default version 3 KDBX header

KdbxHeader

public KdbxHeader(int version)

Construct a default KDBX header with AES/AES/SALSA_20

KdbxHeader

public KdbxHeader(org.linguafranca.pwdb.kdbx.KdbxHeader.KdbxHeaderOptions opts)

Method Detail

getHmacKey

public byte[] getHmacKey(Credentials credentials)

Compute the Hmac Key Digest from "KdbxFile.cs Computekeys"

Parameters:

credentials - the credentials

Returns:

the digest

verifyHeaderHmac

public void verifyHeaderHmac(byte[] key,
                             byte[] bytes)

Verify the header Hmac

Parameters:

key - the transformed Hmac Key for the header

bytes - the bytes to compare to verify

createDecryptedStream

public InputStream createDecryptedStream(byte[] digest,
                                         InputStream inputStream)

Create a decrypted input stream using supplied digest and this header apply decryption to the passed encrypted input stream

Parameters:

digest - the key digest

inputStream - the encrypted input stream

Returns:

a decrypted stream

getInnerStreamEncryptor

public StreamEncryptor getInnerStreamEncryptor()

getTransformedKeyDigest

public byte[] getTransformedKeyDigest(byte[] digest)

Takes the composite credentials and transforms them according to the underlying KDF algorithm.

Parameters:

digest - the credentials digested

Returns:

the transformed digest

createEncryptedStream

public OutputStream createEncryptedStream(byte[] digest,
                                          OutputStream outputStream)

Create an unencrypted outputStream using the supplied digest and this header and use the supplied output stream to write encrypted data.

Parameters:

digest - the key digest

outputStream - the output stream which is the destination for encrypted data

Returns:

an output stream to write unencrypted data to

getTransformSeed

public byte[] getTransformSeed()

getTransformRounds

public long getTransformRounds()

getCipherUuid

public UUID getCipherUuid()

getCompressionFlags

public KdbxHeader.CompressionFlags getCompressionFlags()

getMasterSeed

public byte[] getMasterSeed()

getEncryptionIv

public byte[] getEncryptionIv()

getInnerRandomStreamKey

public byte[] getInnerRandomStreamKey()

getStreamStartBytes

public byte[] getStreamStartBytes()

getCipherAlgorithm

public CipherAlgorithm getCipherAlgorithm()

getKeyDerivationFunction

public KeyDerivationFunction getKeyDerivationFunction()

getProtectedStreamAlgorithm

public Encryption.ProtectedStreamAlgorithm getProtectedStreamAlgorithm()

getHeaderHash

public byte[] getHeaderHash()

getVersion

public int getVersion()

getKdfParameters

public VariantDictionary getKdfParameters()

getStreamEncryptor

public StreamEncryptor getStreamEncryptor()

setCompressionFlags

public void setCompressionFlags(int flags)

setMasterSeed

public void setMasterSeed(byte[] masterSeed)

setTransformSeed

public void setTransformSeed(byte[] transformSeed)

setTransformRounds

public void setTransformRounds(long transformRounds)

setEncryptionIv

public void setEncryptionIv(byte[] encryptionIv)

setInnerRandomStreamKey

public void setInnerRandomStreamKey(byte[] key)

setStreamStartBytes

public void setStreamStartBytes(byte[] streamStartBytes)

setInnerRandomStreamId

public void setInnerRandomStreamId(int innerRandomStreamId)

setProtectedStreamAlgorithm

public void setProtectedStreamAlgorithm(Encryption.ProtectedStreamAlgorithm protectedStreamAlgorithm)

setKeyDerivationFunction

public void setKeyDerivationFunction(KeyDerivationFunction keyDerivationFunction)

setCipherAlgorithm

public void setCipherAlgorithm(CipherAlgorithm cipherAlgorithm)

setCipherUuid

public void setCipherUuid(byte[] uuid)

setCipherUuid

public void setCipherUuid(UUID uuid)

setHeaderHash

public void setHeaderHash(byte[] headerHash)

setVersion

public void setVersion(int version)

setKdfParameters

public void setKdfParameters(VariantDictionary kdfParameters)

V4 add Key Definition Function Parameters

setCustomData

public void setCustomData(VariantDictionary customData)

V4 Add custom data

addBinary

public void addBinary(byte[] bytes)

V4 add binary from inner header

getBinaries

public List<byte[]> getBinaries()

getHeaderBytes

public byte[] getHeaderBytes()

V4 provide access to the header as bytes for verification

setHeaderBytes

public void setHeaderBytes(byte[] headerBytes)

V4 provide access to the header as bytes for verification