public V2DocumentHeaders(EncryptionParameters encryptionParameters, long keyWrapIterations)
{
if (encryptionParameters == null)
{
throw new ArgumentNullException("encryptionParameters");
}
_headers = new Headers();
_headers.HeaderBlocks.Add(new PreambleHeaderBlock());
_headers.HeaderBlocks.Add(new VersionHeaderBlock(_version));
ICryptoFactory cryptoFactory = Resolve.CryptoFactory.Create(encryptionParameters.CryptoId);
IDerivedKey keyEncryptingKey = cryptoFactory.CreateDerivedKey(encryptionParameters.Passphrase);
V2KeyWrapHeaderBlock keyWrap = new V2KeyWrapHeaderBlock(cryptoFactory, keyEncryptingKey, keyWrapIterations);
_headers.HeaderBlocks.Add(keyWrap);
_keyStreamFactory = keyWrap;
foreach (UserPublicKey publicKey in encryptionParameters.PublicKeys)
{
_headers.HeaderBlocks.Add(new V2AsymmetricKeyWrapHeaderBlock(publicKey, keyWrap.MasterKey, keyWrap.MasterIV));
}
_headers.HeaderBlocks.Add(new V2AsymmetricRecipientsEncryptedHeaderBlock(GetHeaderCrypto(HeaderBlockType.AsymmetricRecipients))
{
Recipients = new Recipients(encryptionParameters.PublicKeys)
});
_headers.HeaderBlocks.Add(new FileInfoEncryptedHeaderBlock(GetHeaderCrypto(HeaderBlockType.FileInfo)));
_headers.HeaderBlocks.Add(new V2CompressionEncryptedHeaderBlock(GetHeaderCrypto(HeaderBlockType.Compression)));
_headers.HeaderBlocks.Add(new V2UnicodeFileNameInfoEncryptedHeaderBlock(GetHeaderCrypto(HeaderBlockType.UnicodeFileNameInfo)));
_headers.HeaderBlocks.Add(new V2AlgorithmVerifierEncryptedHeaderBlock(GetHeaderCrypto(HeaderBlockType.AlgorithmVerifier)));
_headers.HeaderBlocks.Add(new DataHeaderBlock());
SetDataEncryptingCryptoForEncryptedHeaderBlocks(_headers.HeaderBlocks);
}
/// <summary>
/// Check if one instance is equivalent to another.
/// </summary>
/// <param name="other">The instance to compare to</param>
/// <returns>true if the keys are equivalent</returns>
public bool Equals(IDerivedKey other)
{
if (Object.ReferenceEquals(other, null))
{
return(false);
}
return(DerivedKey == other.DerivedKey);
}
public V2KeyWrapHeaderBlock(ICryptoFactory cryptoFactory, IDerivedKey keyEncryptingKey, long keyWrapIterations)
: this(Resolve.RandomGenerator.Generate(DATABLOCK_LENGTH))
{
_cryptoFactory = cryptoFactory;
_keyEncryptingKey = keyEncryptingKey;
Initialize(keyWrapIterations);
}
public override bool Equals(object obj)
{
IDerivedKey other = obj as IDerivedKey;
if (other == null)
{
return(false);
}
return(Equals(other));
}
public void RewrapMasterKey(IDerivedKey keyEncryptingKey, long keyWrapIterations)
{
if (keyEncryptingKey == null)
{
throw new ArgumentNullException("keyEncryptingKey");
}
V1KeyWrap1HeaderBlock keyHeaderBlock = _headers.FindHeaderBlock <V1KeyWrap1HeaderBlock>();
keyHeaderBlock.RewrapMasterKey(GetMasterKey(), keyEncryptingKey.DerivedKey, keyWrapIterations);
_keyEncryptingKey = keyEncryptingKey;
}
public V1DocumentHeaders(V1DocumentHeaders documentHeaders)
{
if (documentHeaders == null)
{
throw new ArgumentNullException("documentHeaders");
}
_keyEncryptingKey = documentHeaders._keyEncryptingKey;
foreach (HeaderBlock headerBlock in documentHeaders._headers.HeaderBlocks)
{
_headers.HeaderBlocks.Add((HeaderBlock)headerBlock.Clone());
}
}
/// <summary>
/// Loads an AxCrypt file from the specified reader. After this, the reader is positioned to
/// read encrypted data.
/// </summary>
/// <param name="passphrase">The passphrase.</param>
/// <param name="cryptoId">The crypto identifier.</param>
/// <param name="reader">The reader.</param>
/// <param name="headers">The headers.</param>
/// <returns>
/// True if the key was valid, false if it was wrong.
/// </returns>
private bool Load(Passphrase passphrase, Guid cryptoId, AxCryptReader reader, Headers headers)
{
ResetState();
if (cryptoId == new V1Aes128CryptoFactory().CryptoId)
{
return(PassphraseIsValid);
}
_reader = reader;
CryptoFactory = Resolve.CryptoFactory.Create(cryptoId);
V2KeyWrapHeaderBlock keyWrap = headers.FindHeaderBlock <V2KeyWrapHeaderBlock>();
IDerivedKey key = CryptoFactory.RestoreDerivedKey(passphrase, keyWrap.DerivationSalt, keyWrap.DerivationIterations);
keyWrap.SetDerivedKey(CryptoFactory, key);
DocumentHeaders = new V2DocumentHeaders(keyWrap);
PassphraseIsValid = DocumentHeaders.Load(headers);
Properties = EncryptedProperties.Create(this);
return(PassphraseIsValid);
}
public void SetDerivedKey(ICryptoFactory cryptoFactory, IDerivedKey keyEncryptingKey)
{
_cryptoFactory = cryptoFactory;
_keyEncryptingKey = keyEncryptingKey;
_unwrappedKeyData = null;
}
public V1DocumentHeaders(Passphrase passphrase)
{
_keyEncryptingKey = Resolve.CryptoFactory.Create(new V1Aes128CryptoFactory().CryptoId).CreateDerivedKey(passphrase);
}
