/**
* Copyright Microsoft Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.microsoft.azure.storage.core;
import java.io.IOException;
import java.io.StringWriter;
import java.util.HashMap;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.JsonToken;
import com.microsoft.azure.storage.Constants;
/**
* RESERVED FOR INTERNAL USE. Represents the encryption data that is stored on the service.
*/
public class EncryptionData {
/**
* The content encryption IV.
*/
private byte[] contentEncryptionIV;
/**
* The encryption agent.
*/
private EncryptionAgent encryptionAgent;
/**
* A {@link WrappedContentKey} object that stores the wrapping algorithm, key identifier and the encrypted key
* bytes.
*/
private WrappedContentKey wrappedContentKey;
/**
* Metadata for encryption. Currently used only for storing the encryption library, but may contain other data.
*/
private HashMap<String, String> keyWrappingMetadata;
/**
* Gets the content encryption IV.
*
* @return The content encryption IV.
*/
public byte[] getContentEncryptionIV() {
return this.contentEncryptionIV;
}
/**
* Gets the encryption agent that is used to identify the encryption protocol version and encryption algorithm.
*
* @return The encryption agent.
*/
public EncryptionAgent getEncryptionAgent() {
return this.encryptionAgent;
}
/**
* Gets the wrapped key that is used to store the wrapping algorithm, key identifier and the encrypted key bytes.
*
* @return A {@link WrappedContentKey} object that stores the wrapping algorithm, key identifier and the encrypted
* key bytes.
*/
public WrappedContentKey getWrappedContentKey() {
return this.wrappedContentKey;
}
/**
* Gets the metadata for encryption.
*
* @return A HashMap containing the encryption metadata in a key-value format.
*/
public HashMap<String, String> getKeyWrappingMetadata() {
return this.keyWrappingMetadata;
}
/**
* Sets the content encryption IV.
*
* @param contentEncryptionIV
* The content encryption IV.
*/
public void setContentEncryptionIV(byte[] contentEncryptionIV) {
this.contentEncryptionIV = contentEncryptionIV;
}
/**
* Sets the encryption agent that is used to identify the encryption protocol version and encryption algorithm.
*
* @param encryptionAgent
* The encryption agent.
*/
public void setEncryptionAgent(EncryptionAgent encryptionAgent) {
this.encryptionAgent = encryptionAgent;
}
/**
* Sets the wrapped key that is used to store the wrapping algorithm, key identifier and the encrypted key bytes.
*
* @param wrappedContentKey
* A {@link WrappedContentKey} object that stores the wrapping algorithm, key identifier and the
* encrypted key bytes.
*/
public void setWrappedContentKey(WrappedContentKey wrappedContentKey) {
this.wrappedContentKey = wrappedContentKey;
}
/**
* Sets the metadata for encryption.
*
* @param keyWrappingMetadata A HashMap containing the encryption metadata in a key-value format.
*/
public void setKeyWrappingMetadata(HashMap<String, String> keyWrappingMetadata) {
this.keyWrappingMetadata = keyWrappingMetadata;
}
public String serialize() throws IOException {
final StringWriter strWriter = new StringWriter();
JsonGenerator generator = Utility.getJsonGenerator(strWriter);
try {
// start object
generator.writeStartObject();
this.serialize(generator);
// end object
generator.writeEndObject();
}
finally {
generator.close();
}
return strWriter.toString();
}
public void serialize(JsonGenerator generator) throws IOException {
// write wrapped content key
generator.writeObjectFieldStart(Constants.EncryptionConstants.WRAPPED_CONTENT_KEY);
this.getWrappedContentKey().serialize(generator);
generator.writeEndObject();
// write encryption agent
generator.writeObjectFieldStart(Constants.EncryptionConstants.ENCRYPTION_AGENT);
this.getEncryptionAgent().serialize(generator);
generator.writeEndObject();
// write content encryption IV
generator.writeBinaryField(Constants.EncryptionConstants.CONTENT_ENCRYPTION_IV, this.getContentEncryptionIV());
// write key wrapping metadata
generator.writeObjectFieldStart(Constants.EncryptionConstants.KEY_WRAPPING_METADATA);
for (String key : this.keyWrappingMetadata.keySet()) {
generator.writeStringField(key, this.keyWrappingMetadata.get(key));
}
generator.writeEndObject();
}
public void copyValues(EncryptionData data) throws JsonProcessingException, IOException {
this.setWrappedContentKey(data.getWrappedContentKey());
this.setEncryptionAgent(data.getEncryptionAgent());
this.setContentEncryptionIV(data.getContentEncryptionIV());
this.setKeyWrappingMetadata(data.getKeyWrappingMetadata());
}
public static EncryptionData deserialize(String inputData)
throws JsonProcessingException, IOException {
JsonParser parser = Utility.getJsonParser(inputData);
try {
if (!parser.hasCurrentToken()) {
parser.nextToken();
}
return EncryptionData.deserialize(parser);
}
finally {
parser.close();
}
}
public static EncryptionData deserialize(JsonParser parser) throws JsonParseException, IOException {
JsonUtilities.assertIsStartObjectJsonToken(parser);
parser.nextToken();
EncryptionData data = new EncryptionData();
while (parser.getCurrentToken() != JsonToken.END_OBJECT) {
String name = parser.getCurrentName();
parser.nextToken();
if (name.equals(Constants.EncryptionConstants.WRAPPED_CONTENT_KEY)) {
data.setWrappedContentKey(WrappedContentKey.deserialize(parser));
}
else if (name.equals(Constants.EncryptionConstants.ENCRYPTION_AGENT)) {
data.setEncryptionAgent(EncryptionAgent.deserialize(parser));
}
else if (name.equals(Constants.EncryptionConstants.CONTENT_ENCRYPTION_IV)) {
data.setContentEncryptionIV(parser.getBinaryValue());
}
else if (name.equals(Constants.EncryptionConstants.KEY_WRAPPING_METADATA)) {
data.setKeyWrappingMetadata(deserializeKeyWrappingMetadata(parser));
}
else {
consumeJsonObject(parser);
}
parser.nextToken();
}
JsonUtilities.assertIsEndObjectJsonToken(parser);
return data;
}
public static HashMap<String, String> deserializeKeyWrappingMetadata(JsonParser parser) throws JsonParseException, IOException {
JsonUtilities.assertIsStartObjectJsonToken(parser);
parser.nextToken();
HashMap<String, String> keyWrappingMetadata = new HashMap<String, String>();
while (parser.getCurrentToken() != JsonToken.END_OBJECT) {
String name = parser.getCurrentName();
parser.nextToken();
keyWrappingMetadata.put(name, parser.getValueAsString());
parser.nextToken();
}
JsonUtilities.assertIsEndObjectJsonToken(parser);
return keyWrappingMetadata;
}
public static void consumeJsonObject(JsonParser parser) throws IOException {
JsonUtilities.assertIsStartObjectJsonToken(parser);
parser.nextToken();
if (parser.getCurrentToken() != JsonToken.END_OBJECT) {
consumeJsonObject(parser);
}
}
}