private bool IsBinaryDataValid(byte[] data, string dataHash)
{
var tokenProvider = new Sha256FileTokenProvider();
using (var source = new MemoryStream(data))
{
string newDataHash = tokenProvider.ComputeToken(source);
if (newDataHash != dataHash)
{
// Try older versions
newDataHash = CryptoHelper.ComputeSha1Hash(source);
if (newDataHash != dataHash)
{
// Might be a sha256 hash
newDataHash = CryptoHelper.ComputeSha256Hash(source);
if (newDataHash != dataHash)
{
return(false);
}
}
}
}
return(true);
}
/// <summary>
/// Formats the specified source.
/// </summary>
/// <param name="source">The source.</param>
/// <returns>
/// A collection of alias->value pairs.
/// </returns>
public IEnumerable <KeyValuePair <string, object> > Format(string source)
{
if (string.IsNullOrEmpty(source))
{
return(null);
}
var tokenProvider = new Sha256FileTokenProvider();
string hash;
using (var stream = File.OpenRead(source))
{
hash = tokenProvider.ComputeToken(stream);
}
/////
// Only member of interest here is the data hash.
/////
var members = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>("core:fileDataHash", hash)
};
return(members);
}
/// <summary>
/// Perform any registrations
/// </summary>
/// <param name="builder">The autofac container builder.</param>
protected override void Load(ContainerBuilder builder)
{
var sha256TokenProvider = new Sha256FileTokenProvider();
var randomTokenProvider = new RandomFileTokenProvider();
// Register file repositories
builder.Register(c => FileRepositoryFactory.CreateFileRepository(ApplicationLibraryFileRepositoryConfigName, sha256TokenProvider, @"C:\PlatformFileRepos\AppLibrary", TimeSpan.MaxValue))
.Named <FileRepository>(ApplicationLibraryFileRepositoryName)
.Named <IFileRepository>(ApplicationLibraryFileRepositoryName)
.As <IFileRepository>()
.SingleInstance();
// Only keep files for 1 day
builder.Register(c => FileRepositoryFactory.CreateFileRepository(TemporaryFileRepositoryConfigName, randomTokenProvider, @"C:\PlatformFileRepos\Temporary", TimeSpan.FromDays(1)))
.Named <FileRepository>(TemporaryFileRepositoryName)
.Named <IFileRepository>(TemporaryFileRepositoryName)
.As <IFileRepository>()
.SingleInstance();
builder.Register(c => FileRepositoryFactory.CreateFileRepository(BinaryFileRepositoryConfigName, sha256TokenProvider, @"C:\PlatformFileRepos\Binary", TimeSpan.MaxValue))
.Named <FileRepository>(BinaryFileRepositoryName)
.Named <IFileRepository>(BinaryFileRepositoryName)
.As <IFileRepository>()
.SingleInstance();
builder.Register(c => FileRepositoryFactory.CreateFileRepository(DocumentFileRepositoryConfigName, sha256TokenProvider, @"C:\PlatformFileRepos\Document", TimeSpan.MaxValue))
.Named <FileRepository>(DocumentFileRepositoryName)
.Named <IFileRepository>(DocumentFileRepositoryName)
.As <IFileRepository>()
.SingleInstance();
}
public void ComputeTokenIsRandomTest()
{
var tokens = new HashSet <string>();
var provider = new Sha256FileTokenProvider();
byte[] data = { 1, 2, 3, 4, 5, 6 };
using (var ms = new MemoryStream(data))
{
tokens.Add(provider.ComputeToken(ms));
}
using (var ms = new MemoryStream(data))
{
tokens.Add(provider.ComputeToken(ms));
}
Assert.AreEqual(1, tokens.Count, "The number of tokens is invalid");
byte[] data2 = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
using (var ms = new MemoryStream(data2))
{
tokens.Add(provider.ComputeToken(ms));
}
Assert.AreEqual(2, tokens.Count, "The number of tokens is invalid");
}
public void ComputeTokenInvalidStreamTest()
{
var provider = new Sha256FileTokenProvider();
Assert.That(() => provider.ComputeToken(null),
Throws.TypeOf <ArgumentNullException>().And.Property("ParamName").EqualTo("stream"));
}
public void TestGetImage( )
{
PhotoFileType image1Entity = null;
try
{
// Create the image
image1Entity = CreateImage1( );
using (var request = new PlatformHttpRequest(string.Format(@"data/v1/image/{0}", image1Entity.Id)))
{
HttpWebResponse response = request.GetResponse( );
// check that it worked (200)
Assert.IsTrue(response.StatusCode == HttpStatusCode.OK);
using (var ms = new MemoryStream( ))
using (var originalImage = new MemoryStream( ))
{
using (Stream dataStream = response.GetResponseStream( ))
{
Assert.IsNotNull(dataStream);
dataStream.CopyTo(ms);
}
// Get the actual image as a memory stream
using (FileStream fs = File.Open(Image1Jpg, FileMode.Open, FileAccess.Read, FileShare.Read))
{
fs.CopyTo(originalImage);
}
Sha256FileTokenProvider tokenProvider = new Sha256FileTokenProvider();
// Compare the values
string streamHash = tokenProvider.ComputeToken(ms);
string fileHash = tokenProvider.ComputeToken(originalImage);
string eTagValue = response.Headers.Get("ETag");
Assert.AreEqual(fileHash, streamHash, "The file hash is invalid");
Assert.AreEqual("\"" + fileHash + "\"", eTagValue, "The ETag value is invalid");
}
}
}
finally
{
if (image1Entity != null)
{
image1Entity.Delete( );
}
}
}
private FileRepository CreateTestRepository(string tempRepoPath, bool allowDuplicates, TimeSpan retentionPeriod, TimeSpan cleanupInterval)
{
var mockRepo = new MockRepository(MockBehavior.Loose);
var eventLogMock = mockRepo.Create <IEventLog>();
IFileTokenProvider tokenProvider;
if (allowDuplicates)
{
tokenProvider = new RandomFileTokenProvider();
}
else
{
tokenProvider = new Sha256FileTokenProvider();
}
return(new FileRepository("TestRepo", tempRepoPath, tokenProvider, eventLogMock.Object, retentionPeriod, cleanupInterval));
}
/// <summary>
/// Gets the binary data.
/// </summary>
/// <param name="context">The context.</param>
/// <returns></returns>
public IEnumerable <BinaryDataEntry> GetBinaryData(IProcessingContext context)
{
var tokenProvider = new Sha256FileTokenProvider();
/////
// Get the binaries that belong to the active solution and convert them into the BinaryDataEntry format.
/////
return(Binaries.Where(pair => pair.Key == ActiveSolution).Select(pair =>
{
string hash;
using (var stream = File.OpenRead(pair.Value))
{
hash = tokenProvider.ComputeToken(stream);
}
return new BinaryDataEntry
{
Data = File.ReadAllBytes(pair.Value),
DataHash = hash
};
}));
}
public void TestGetImageThumbnail( )
{
PhotoFileType image1Entity = null;
try
{
// Create the image
image1Entity = CreateImage1( );
var thumbnailSize = Entity.Get <ThumbnailSizeEnum>(new EntityRef("console", "smallThumbnail"));
// Get the thumbnail
using (
var request =
new PlatformHttpRequest(string.Format(@"data/v1/image/thumbnail/{0}/console-smallThumbnail/core-cropImage", image1Entity.Id)))
{
HttpWebResponse response = request.GetResponse( );
// check that it worked (200)
Assert.IsTrue(response.StatusCode == HttpStatusCode.OK);
using (var ms = new MemoryStream( ))
{
using (Stream dataStream = response.GetResponseStream( ))
{
Assert.IsNotNull(dataStream);
dataStream.CopyTo(ms);
}
using (Image image = Image.FromStream(ms))
{
Assert.AreEqual(image.Width, thumbnailSize.ThumbnailWidth, "The image width is invalid");
Assert.AreEqual(image.Height, thumbnailSize.ThumbnailHeight, "The image height is invalid");
}
Sha256FileTokenProvider tokenProvider = new Sha256FileTokenProvider();
string streamHash = tokenProvider.ComputeToken(ms);
string fileHash;
using (FileStream fs = File.Open(Image1Jpg, FileMode.Open, FileAccess.Read, FileShare.Read))
{
fileHash = tokenProvider.ComputeToken(fs);
}
Assert.AreNotEqual(fileHash, streamHash, "The file hash should not match");
string eTagValue = response.Headers.Get("ETag");
string expectedETag = GetImageThumbnailETag(fileHash, new EntityRef("console", "smallThumbnail"),
new EntityRef("core", "cropImage"));
Assert.AreNotEqual("\"" + expectedETag + "\"", eTagValue, "The ETag is invalid");
}
}
}
finally
{
if (image1Entity != null)
{
image1Entity.Delete( );
}
}
}
