public string SerializeEncrypt(string key, byte[] initVectorArray, object value)
{
var byteArrayKey = CryptoService.CreateByteArrayKey(key);
var serializer = new JsonSerializer
{
ContractResolver = _encryptionFactory.GetContractResolver()
};
string serialized;
// per serialize session
using (var algorithm = new AesManaged
{
Key = byteArrayKey,
IV = initVectorArray
})
{
using (_encryptionFactory.GetEncryptSession(algorithm))
{
var builder = new StringBuilder();
using (var writer = new StringWriter(builder))
{
serializer.Serialize(writer, value);
}
return(serialized = builder.ToString());
}
}
}
void Usage(byte[] key)
{
#region RebugsUsage
var activator = new BuiltinHandlerActivator();
activator.Register(() => new Handler());
var configurer = Configure.With(activator);
var encryptionFactory = new EncryptionFactory();
var settings = new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.All,
ContractResolver = encryptionFactory.GetContractResolver()
};
configurer.Serialization(s => { s.UseNewtonsoftJson(settings); });
configurer.EnableJsonEncryption(
encryptionFactory: encryptionFactory,
encryptStateBuilder: () =>
(
algorithm: new RijndaelManaged
{
Key = key
},
keyId: "1"
),
decryptStateBuilder: (keyId, initVector) =>
new RijndaelManaged
{
Key = key,
IV = initVector
});
#endregion
}
public async Task Works()
{
var target = new ClassWithString
{
Property = "Foo"
};
using var factory = new EncryptionFactory();
using var algorithm = CryptoBuilder.Build();
var serializer = new JsonSerializer
{
ContractResolver = factory.GetContractResolver()
};
string serialized;
using (factory.GetEncryptSession(algorithm))
{
await Task.Delay(1);
serialized = serializer.Serialize(target);
}
using (factory.GetDecryptSession(algorithm))
{
await Task.Delay(1);
var result = serializer.Deserialize <ClassWithString>(serialized);
Assert.Equal("Foo", result.Property);
}
}
public void RoundTrip()
{
var factory = new EncryptionFactory();
var serializer = new JsonSerializer
{
ContractResolver = factory.GetContractResolver()
};
using (var algorithm = CryptoBuilder.Build())
{
string serialized;
using (factory.GetEncryptSession(algorithm))
{
var instance = new ClassToSerialize
{
Property1 = "Property1Value",
Property2 = "Property2Value"
};
serialized = serializer.Serialize(instance);
}
using (factory.GetDecryptSession(algorithm))
{
var result = serializer.Deserialize <ClassToSerialize>(serialized);
ObjectApprover.VerifyWithJson(result);
}
}
}
public static void ConfigurationEncryption(this EndpointConfiguration endpointConfiguration)
{
var key = Encoding.UTF8.GetBytes("gdDbqRpqdRbTs3mhdZh9qCaDaxJXl+e6");
var serialization = endpointConfiguration.UseSerialization <NewtonsoftSerializer>();
var encryptionFactory = new EncryptionFactory();
serialization.Settings(
new JsonSerializerSettings
{
ContractResolver = encryptionFactory.GetContractResolver()
});
endpointConfiguration.EnableJsonEncryption(
encryptionFactory: encryptionFactory,
encryptStateBuilder: () =>
(
algorithm: new RijndaelManaged
{
Key = key
},
keyId: "1"
),
decryptStateBuilder: (keyId, initVector) =>
new RijndaelManaged
{
Key = key,
IV = initVector
});
}
void Usage(byte[] key)
{
#region NsbUsage
var configuration = new EndpointConfiguration("NServiceBusSample");
var serialization = configuration.UseSerialization <NewtonsoftSerializer>();
var encryptionFactory = new EncryptionFactory();
serialization.Settings(
new()
{
ContractResolver = encryptionFactory.GetContractResolver()
});
configuration.EnableJsonEncryption(
encryptionFactory: encryptionFactory,
encryptStateBuilder: () =>
(
algorithm: new RijndaelManaged
{
Key = key
},
keyId: "1"
),
decryptStateBuilder: (keyId, initVector) =>
new RijndaelManaged
{
Key = key,
IV = initVector
});
#endregion
}
static void Main()
{
// per system (periodically rotated)
var key = Encoding.UTF8.GetBytes("gdDbqRpqdRbTs3mhdZh9qCaDaxJXl+e6");
// per app domain
using (var factory = new EncryptionFactory())
{
var serializer = new JsonSerializer
{
ContractResolver = factory.GetContractResolver()
};
// transferred as meta data with the serialized payload
byte[] initVector;
string serialized;
// per serialize session
using (var algorithm = new RijndaelManaged
{
Key = key
})
{
initVector = algorithm.IV;
using (factory.GetEncryptSession(algorithm))
{
var instance = new ClassToSerialize
{
Property = "PropertyValue",
};
var builder = new StringBuilder();
using (var writer = new StringWriter(builder))
{
serializer.Serialize(writer, instance);
}
serialized = builder.ToString();
}
}
// per deserialize session
using (var algorithm = new RijndaelManaged
{
IV = initVector,
Key = key
})
{
using (factory.GetDecryptSession(algorithm))
{
using var stringReader = new StringReader(serialized);
using var jsonReader = new JsonTextReader(stringReader);
var deserialized = serializer.Deserialize <ClassToSerialize>(jsonReader);
Console.WriteLine(deserialized !.Property);
}
}
}
Console.ReadKey();
}
static async Task Main()
{
var key = Encoding.UTF8.GetBytes("gdDbqRpqdRbTs3mhdZh9qCaDaxJXl+e6");
Console.Title = "RebusSample";
var directory = Directory.GetParent(Assembly.GetEntryAssembly().Location).FullName;
var activator = new BuiltinHandlerActivator();
activator.Register(() => new Handler());
var configurer = Configure.With(activator);
var encryptionFactory = new EncryptionFactory();
var settings = new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.All,
ContractResolver = encryptionFactory.GetContractResolver()
};
configurer.Serialization(s => { s.UseNewtonsoftJson(settings); });
configurer.EnableJsonEncryption(
encryptionFactory: encryptionFactory,
encryptStateBuilder: () =>
(
algorithm: new RijndaelManaged
{
Key = key
},
keyId: "1"
),
decryptStateBuilder: (keyId, initVector) =>
new RijndaelManaged
{
Key = key,
IV = initVector
});
configurer.Transport(t =>
{
t.UseFileSystem(directory, "RebusSample");
});
var bus = configurer.Start();
Console.WriteLine("Press any key to exit");
await SendMessage(bus)
.ConfigureAwait(false);
Console.ReadKey();
bus?.Dispose();
encryptionFactory.Dispose();
activator.Dispose();
}
public void ExampleUsage()
{
// per system (periodically rotated)
var key = Encoding.UTF8.GetBytes("gdDbqRpqdRbTs3mhdZh9qCaDaxJXl+e6");
// per app domain
using (var factory = new EncryptionFactory())
{
var serializer = new JsonSerializer
{
ContractResolver = factory.GetContractResolver()
};
// transferred as meta data with the serialized payload
byte[] initVector;
string serialized;
// per serialize session
using (var algorithm = new RijndaelManaged
{
Key = key
})
{
initVector = algorithm.IV;
using (factory.GetEncryptSession(algorithm))
{
var instance = new ClassToSerialize
{
Property1 = "Property1Value",
Property2 = "Property2Value"
};
serialized = serializer.Serialize(instance);
}
}
// per deserialize session
using (var algorithm = new RijndaelManaged
{
IV = initVector,
Key = key
})
{
using (factory.GetDecryptSession(algorithm))
{
var deserialized = serializer.Deserialize <ClassToSerialize>(serialized);
ObjectApprover.VerifyWithJson(deserialized);
}
}
}
}
static async Task Main()
{
var key = Encoding.UTF8.GetBytes("gdDbqRpqdRbTs3mhdZh9qCaDaxJXl+e6");
Console.Title = "NServiceBusSample";
var configuration = new EndpointConfiguration("NServiceBusSample");
var serialization = configuration.UseSerialization <NewtonsoftSerializer>();
var encryptionFactory = new EncryptionFactory();
serialization.Settings(
new JsonSerializerSettings
{
ContractResolver = encryptionFactory.GetContractResolver()
});
configuration.EnableJsonEncryption(
encryptionFactory: encryptionFactory,
encryptStateBuilder: () =>
(
algorithm: new RijndaelManaged
{
Key = key
},
keyId: "1"
),
decryptStateBuilder: (keyId, initVector) =>
new RijndaelManaged
{
Key = key,
IV = initVector
});
configuration.UsePersistence <LearningPersistence>();
configuration.UseTransport <LearningTransport>();
var endpointInstance = await Endpoint.Start(configuration)
;
Console.WriteLine("Press any key to exit");
await SendMessage(endpointInstance)
;
Console.ReadKey();
await endpointInstance.Stop()
;
encryptionFactory.Dispose();
}
public void Simple()
{
var factory = new EncryptionFactory();
var serializer = new JsonSerializer
{
ContractResolver = factory.GetContractResolver()
};
using (var algorithm = CryptoBuilder.Build())
using (factory.GetEncryptSession(algorithm))
{
var instance = new ClassToSerialize
{
Property1 = "Property1Value",
Property2 = "Property2Value"
};
var result = serializer.Serialize(instance);
Approvals.Verify(result);
}
}
public static T Run <T>(T instance)
{
using (var factory = new EncryptionFactory())
using (var algorithm = CryptoBuilder.Build())
{
var serializer = new JsonSerializer
{
ContractResolver = factory.GetContractResolver()
};
string result;
using (factory.GetEncryptSession(algorithm))
{
result = serializer.Serialize(instance);
}
Approvals.Verify(result);
using (factory.GetDecryptSession(algorithm))
{
return(serializer.Deserialize <T>(result));
}
}
}
public static async Task <T> Run <T>(T instance, [CallerFilePath] string sourceFile = "")
{
using var factory = new EncryptionFactory();
using var algorithm = CryptoBuilder.Build();
var serializer = new JsonSerializer
{
ContractResolver = factory.GetContractResolver()
};
string result;
using (factory.GetEncryptSession(algorithm))
{
result = serializer.Serialize(instance);
}
await Verify(result, null, sourceFile);
using (factory.GetDecryptSession(algorithm))
{
return(serializer.Deserialize <T>(result));
}
}
