private static void CalculateDeltaInternal(string sourcePath, string targetPath, string deltaPath, string signaturePath, int chunkSize, FilePatchProgress progressReporter = null)
{
using (var signatureStream = new FileStream(signaturePath, FileMode.Create, FileAccess.ReadWrite, FileShare.Read))
{
using (var basisStream = new FileStream(sourcePath, FileMode.Open, FileAccess.Read, FileShare.Read))
{
SignatureBuilder sb = new SignatureBuilder {
ChunkSize = (short)chunkSize
};
sb.Build(basisStream, new SignatureWriter(signatureStream));
}
signatureStream.Position = 0L;
using (var newFileStream = new FileStream(targetPath, FileMode.Open, FileAccess.Read, FileShare.Read))
using (var deltaStream = new FileStream(deltaPath, FileMode.Create, FileAccess.Write, FileShare.Read))
{
IProgressReporter reporter = progressReporter;
if (reporter == null)
{
reporter = new NullProgressReporter();
}
new DeltaBuilder().BuildDelta(newFileStream, new SignatureReader(signatureStream, reporter), new AggregateCopyOperationsDecorator(new BinaryDeltaWriter(deltaStream)));
}
}
}
public void SignatureBuilderSha1_ForRandomData_BuildsSignature(int numberOfBytes, short chunkSize)
{
// Arrange
var data = new byte[numberOfBytes];
new Random().NextBytes(data);
var dataStream = new MemoryStream(data);
var signatureStream = new MemoryStream();
var progressReporter = Substitute.For <IProgress <ProgressReport> >();
// Act
var target = new SignatureBuilder(SupportedAlgorithms.Hashing.Sha1(), SupportedAlgorithms.Checksum.Adler32Rolling())
{
ChunkSize = chunkSize,
ProgressReport = progressReporter
};
target.Build(dataStream, new SignatureWriter(signatureStream));
// Assert
CommonAsserts.ValidateSignature(signatureStream, new HashAlgorithmWrapper("SHA1", SHA1.Create()), Utils.GetMd5(data), new Adler32RollingChecksum());
progressReporter.Received().Report(Arg.Any <ProgressReport>());
}
public void SignatureBuilderXXHash_BuildsSignature()
{
// Arrange
const int dataLength = 1037;
var data = new byte[dataLength];
new Random(RandomSeed).NextBytes(data);
var dataStream = new MemoryStream(data);
var signatureStream = new MemoryStream();
var progressReporter = Substitute.For <IProgress <ProgressReport> >();
// Act
var target = new SignatureBuilder
{
ProgressReport = progressReporter
};
target.Build(dataStream, new SignatureWriter(signatureStream));
// Assert
CollectionAssert.AreEqual(xxhash1037TestSignature, signatureStream.ToArray());
CommonAsserts.ValidateSignature(signatureStream, new XxHashAlgorithm(), Utils.GetMd5(data), new Adler32RollingChecksum());
progressReporter.Received().Report(Arg.Any <ProgressReport>());
}
public void PostSignatureTest()
{
Field[] fields =
{
new Field
{
Name = "caseName",
Value = "Hollywood Mogul vs. Oil Shotgun Well",
DataType = "string",
FieldType = "text"
},
new Field
{
Name = "claimantName",
Value = "Jed Clampett",
DataType = "string",
FieldType = "text"
}
};
SignatureRequest request = new SignatureRequest
{
DocuSignTemplateId = _W4_Template,
EmailAddresses = new string[] { "*****@*****.**" },
Subject = "SigSvc Integration Test Send. Your Document is ready to sign",
Name = "Marty Mazurik",
Fields = fields
};
ISignatureBuilder builder = new SignatureBuilder(_api, _config, null); // fix test _repo would need to be set up
IResponse response;
Assert.IsTrue(builder.Build(request, "*****@*****.**", _password, out response));
}
public byte[] SignatureMd5()
{
dataStream.Seek(0, SeekOrigin.Begin);
var signatureStream = new MemoryStream();
md5SignatureBuilder.Build(dataStream, new SignatureWriter(signatureStream));
return(signatureStream.ToArray());
}
private static void CreateSignature(Stream oldData, FileStream sigStream)
{
Utils.Status("Creating Patch Signature");
var signatureBuilder = new SignatureBuilder();
signatureBuilder.Build(oldData, new SignatureWriter(sigStream));
sigStream.Position = 0;
}
public static byte[] CreateSignature(Stream fileSteStream)
{
var signatureBuilder = new SignatureBuilder();
using (var signatureStream = new MemoryStream())
{
signatureBuilder.Build(fileSteStream, new SignatureWriter(signatureStream));
return(signatureStream.ToArray());
}
}
public static void CreateSignature(string signaturePath, string oldFilePath)
{
var signatureBuilder = new SignatureBuilder();
using (var basisStream = new FileStream(oldFilePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
using (var signatureStream = new FileStream(signaturePath, FileMode.Create, FileAccess.Write, FileShare.Read))
{
signatureBuilder.Build(basisStream, new SignatureWriter(signatureStream));
}
}
private static Stream CreateSignature(byte[] oldData)
{
Utils.Status("Creating Patch Signature");
using var oldDataStream = new MemoryStream(oldData);
var sigStream = new MemoryStream();
var signatureBuilder = new SignatureBuilder();
signatureBuilder.Build(oldDataStream, new SignatureWriter(sigStream));
sigStream.Position = 0;
return(sigStream);
}
protected byte[] ComputeSignature(FileInfo file)
{
SignatureBuilder builder = new SignatureBuilder();
using (FileStream basisStream = file.OpenRead())
using (MemoryStream signatureStream = new MemoryStream())
{
builder.Build(basisStream, new SignatureWriter(signatureStream));
}
return(null);
}
public static (Stream baseDataStream, Stream baseSignatureStream) PrepareTestData(string originalFileName)
{
var baseDataStream = new FileStream(originalFileName, FileMode.Open);
var baseSignatureStream = new MemoryStream();
var signatureBuilder = new SignatureBuilder();
signatureBuilder.Build(baseDataStream, new SignatureWriter(baseSignatureStream));
baseSignatureStream.Seek(0, SeekOrigin.Begin);
return(baseDataStream, baseSignatureStream);
}
public static byte[] CreateSignaturFile(string fileName)
{
var signatureBaseFilePath = FakeAws.Program.GetFile(fileName);
var signatureBuilder = new SignatureBuilder();
using (var basisStream = new MemoryStream(signatureBaseFilePath))
using (var signatureStream = new MemoryStream())
{
signatureBuilder.Build(basisStream, new SignatureWriter(signatureStream));
FakeAws.Program.SaveSignatur(fileName, signatureStream.ToArray());
return(signatureStream.ToArray());
}
}
// Methods
public Byte[] CreateSignature(FileNode node)
{
Byte[] result = null;
var signatureBuilder = new SignatureBuilder();
using (var basisStream = new FileStream(Path.Combine(node.Directory, node.FileName), FileMode.Open, FileAccess.Read, FileShare.Read))
using (var signatureStream = new MemoryStream())
{
signatureBuilder.Build(basisStream, new SignatureWriter(signatureStream));
signatureStream.Position = 0;
result = signatureStream.ToArray();
}
return(result);
}
public Byte[] CreateSignature(Byte[] data)
{
Byte[] result = null;
var signatureBuilder = new SignatureBuilder();
using (var basisStream = new MemoryStream(data))
using (var signatureStream = new MemoryStream())
{
signatureBuilder.Build(basisStream, new SignatureWriter(signatureStream));
signatureStream.Position = 0;
result = signatureStream.ToArray();
}
return(result);
}
public override byte[] Compute()
{
using (Operation op = L.Begin("Build file signature for file {file}", File.FullName))
{
using (FileStream basisStream = File.Open(FileMode.Open, FileAccess.Read, FileShare.Read))
using (MemoryStream ms = new MemoryStream())
{
SignatureWriter octoSigWriter = new SignatureWriter(ms);
SignatureBuilder signatureBuilder = new SignatureBuilder();
signatureBuilder.ProgressReporter = new OctoSigBuildProgressReporter(File);
signatureBuilder.Build(basisStream, octoSigWriter);
ComputedDateTime = DateTime.UtcNow;
op.Complete();
return(ComputedSignature = ms.ToArray());
}
}
}
public int Execute(string[] commandLineArguments)
{
options.Parse(commandLineArguments);
if (string.IsNullOrWhiteSpace(basisFilePath))
{
throw new OptionException("No basis file was specified", "basis-file");
}
basisFilePath = Path.GetFullPath(basisFilePath);
var signatureBuilder = new SignatureBuilder();
foreach (var config in configuration)
{
config(signatureBuilder);
}
if (!File.Exists(basisFilePath))
{
throw new FileNotFoundException("File not found: " + basisFilePath, basisFilePath);
}
if (string.IsNullOrWhiteSpace(signatureFilePath))
{
signatureFilePath = basisFilePath + ".octosig";
}
else
{
signatureFilePath = Path.GetFullPath(signatureFilePath);
var sigDirectory = Path.GetDirectoryName(signatureFilePath);
if (sigDirectory != null && !Directory.Exists(sigDirectory))
{
Directory.CreateDirectory(sigDirectory);
}
}
using (var basisStream = new FileStream(basisFilePath, FileMode.Open, FileAccess.Read, FileShare.Read))
using (var signatureStream = new FileStream(signatureFilePath, FileMode.Create, FileAccess.Write, FileShare.Read))
{
signatureBuilder.Build(basisStream, new SignatureWriter(signatureStream));
}
return(0);
}
private async Task <Stream> AttemptDeltaDownload(string packageId, string version, FileStream basisStream)
{
try
{
var builder = new SignatureBuilder();
using (var signatureStream = new MemoryStream())
{
builder.Build(basisStream, new SignatureWriter(signatureStream));
signatureStream.Seek(0, SeekOrigin.Begin);
basisStream.Seek(0, SeekOrigin.Begin);
using (var delta = await _client.FeedClientWrapper.Create <Stream>(
UrlTemplate.Resolve(_feedRootUri + "/packages/{packageId}/{version}/download-delta", new { packageId, version }),
signatureStream,
"delta",
new Dictionary <string, string>()
))
{
var tempFile = Path.GetTempFileName();
Stream fs = null;
try
{
var deltaApplier = new DeltaApplier {
SkipHashCheck = false
};
fs = new TemporaryFileStream(tempFile, File.Open(tempFile, FileMode.OpenOrCreate, FileAccess.ReadWrite));
deltaApplier.Apply(basisStream, new BinaryDeltaReader(delta, new NullProgressReporter()), fs);
return(fs);
}
catch
{
fs?.Dispose();
throw;
}
}
}
}
catch (Exception ex)
{
_client.Log.Info("Failed delta download: " + ex.Message);
return(null);
}
}
public void SignatureBuilderSyncXXHash_ForEmptyStream_BuildsSignature()
{
// Arrange
var dataStream = new MemoryStream();
var signatureStream = new MemoryStream();
var progressReporter = Substitute.For <IProgress <ProgressReport> >();
// Act
var target = new SignatureBuilder
{
ProgressReport = progressReporter
};
target.Build(dataStream, new SignatureWriter(signatureStream));
// Assert
CommonAsserts.ValidateSignature(signatureStream, new XxHashAlgorithm(), Utils.GetMd5(dataStream.ToArray()), new Adler32RollingChecksum());
progressReporter.Received().Report(Arg.Any <ProgressReport>());
}
public MemoryStream Execute(string[] commandLineArguments, MemoryStream ms = null)
{
// Parse through arguments
options.Parse(commandLineArguments);
// Check if the file path contains a string
if (string.IsNullOrWhiteSpace(basisFilePath))
{
throw new OptionException("No basis file was specified", "basis-file");
}
// Specifiy new files path
basisFilePath = Path.GetFullPath(basisFilePath);
// Set up the signature generator (load options)
var signatureBuilder = new SignatureBuilder();
foreach (var config in configuration)
{
config(signatureBuilder);
}
// Check if the file exists
if (!File.Exists(basisFilePath))
{
throw new FileNotFoundException("File not found: " + basisFilePath, basisFilePath);
}
// Generate signature from file
using (var basisStream = new FileStream(basisFilePath, FileMode.Open, FileAccess.Read, FileShare.Read))
using (var signatureStream = new MemoryStream())//FileStream(signatureFilePath, FileMode.Create, FileAccess.Write, FileShare.Read))
{
signatureBuilder.Build(basisStream, new SignatureWriter(signatureStream));
// Return stream containing signature
return(signatureStream);
}
}
public void GlobalSetup()
{
var baseFileBytes = new byte[BaseFileSize];
var rnd = new Random();
rnd.NextBytes(baseFileBytes);
newFileData = new byte[NewFileSize];
rnd.NextBytes(newFileData);
var baseDataStream = new MemoryStream(baseFileBytes);
newDataStream = new MemoryStream(newFileData);
{
var xxHashSignatureBuilder = new SignatureBuilder(SupportedAlgorithms.Hashing.XxHash(),
SupportedAlgorithms.Checksum.Adler32Rolling());
baseSignaturexxHashStream = new MemoryStream();
xxHashSignatureBuilder.Build(baseDataStream, new SignatureWriter(baseSignaturexxHashStream));
}
{
var sha1SignatureBuilder = new SignatureBuilder(SupportedAlgorithms.Hashing.Sha1(),
SupportedAlgorithms.Checksum.Adler32Rolling());
baseDataStream.Seek(0, SeekOrigin.Begin);
baseSignatureSha1Stream = new MemoryStream();
sha1SignatureBuilder.Build(baseDataStream, new SignatureWriter(baseSignatureSha1Stream));
}
{
var md5SignatureBuilder = new SignatureBuilder(SupportedAlgorithms.Hashing.Md5(),
SupportedAlgorithms.Checksum.Adler32Rolling());
baseDataStream.Seek(0, SeekOrigin.Begin);
baseSignatureMd5Stream = new MemoryStream();
md5SignatureBuilder.Build(baseDataStream, new SignatureWriter(baseSignatureMd5Stream));
}
}
private static (MemoryStream baseDataStream, MemoryStream baseSignatureStream, byte[] newData, MemoryStream newDataStream) PrepareTestData(int baseNumberOfBytes, int newDataNumberOfBytes,
short chunkSize)
{
var baseData = new byte[baseNumberOfBytes];
new Random().NextBytes(baseData);
var baseDataStream = new MemoryStream(baseData);
var baseSignatureStream = new MemoryStream();
var signatureBuilder = new SignatureBuilder
{
ChunkSize = chunkSize
};
signatureBuilder.Build(baseDataStream, new SignatureWriter(baseSignatureStream));
baseSignatureStream.Seek(0, SeekOrigin.Begin);
var newData = new byte[newDataNumberOfBytes];
new Random().NextBytes(newData);
var newDataStream = new MemoryStream(newData);
return(baseDataStream, baseSignatureStream, newData, newDataStream);
}
public async Task PatchingAsyncXXHash_ForTheSameData_PatchesFile(int numberOfBytes, short chunkSize)
{
// Arrange
var baseData = new byte[numberOfBytes];
new Random().NextBytes(baseData);
var baseDataStream = new MemoryStream(baseData);
var baseSignatureStream = new MemoryStream();
var signatureBuilder = new SignatureBuilder
{
ChunkSize = chunkSize
};
signatureBuilder.Build(baseDataStream, new SignatureWriter(baseSignatureStream));
baseSignatureStream.Seek(0, SeekOrigin.Begin);
var newDataStream = new MemoryStream(baseData);
var progressReporter = Substitute.For <IProgress <ProgressReport> >();
// Act
var deltaStream = new MemoryStream();
var deltaBuilder = new DeltaBuilder();
await deltaBuilder.BuildDeltaAsync(newDataStream, new SignatureReader(baseSignatureStream, null), new AggregateCopyOperationsDecorator(new BinaryDeltaWriter(deltaStream))).ConfigureAwait(false);
deltaStream.Seek(0, SeekOrigin.Begin);
var patchedDataStream = new MemoryStream();
var deltaApplier = new DeltaApplier();
await deltaApplier.ApplyAsync(baseDataStream, new BinaryDeltaReader(deltaStream, progressReporter), patchedDataStream).ConfigureAwait(false);
// Assert
CollectionAssert.AreEqual(baseData, patchedDataStream.ToArray());
progressReporter.Received().Report(Arg.Any <ProgressReport>());
}
public void GZip_CompressData_RsyncSignatureAndPatch(int dataLength)
{
// Arrange
var dataBasis = new byte[dataLength];
new Random().NextBytes(dataBasis);
var basisStream = new MemoryStream(dataBasis);
var basisStreamCompressed = new MemoryStream();
var basisStreamCompressedSignature = new MemoryStream();
var newFileStream = new MemoryStream();
newFileStream.Write(dataBasis, 10, dataLength * 4 / 5);
var newRandomData = new byte[dataLength * 2 / 5];
new Random().NextBytes(newRandomData);
newFileStream.Write(newRandomData, 0, newRandomData.Length);
newFileStream.Seek(0, SeekOrigin.Begin);
var newFileStreamCompressed = new MemoryStream();
var deltaStream = new MemoryStream();
var patchedCompressedStream = new MemoryStream();
// Act
GZip.Compress(basisStream, basisStreamCompressed);
basisStreamCompressed.Seek(0, SeekOrigin.Begin);
var signatureBuilder = new SignatureBuilder();
signatureBuilder.Build(basisStreamCompressed, new SignatureWriter(basisStreamCompressedSignature));
basisStreamCompressedSignature.Seek(0, SeekOrigin.Begin);
GZip.Compress(newFileStream, newFileStreamCompressed);
newFileStreamCompressed.Seek(0, SeekOrigin.Begin);
var deltaBuilder = new DeltaBuilder();
deltaBuilder.BuildDelta(newFileStreamCompressed, new SignatureReader(basisStreamCompressedSignature, null),
new AggregateCopyOperationsDecorator(new BinaryDeltaWriter(deltaStream)));
deltaStream.Seek(0, SeekOrigin.Begin);
var deltaApplier = new DeltaApplier
{
SkipHashCheck = true
};
var deltaReader = new BinaryDeltaReader(deltaStream, null);
deltaApplier.Apply(basisStreamCompressed, deltaReader, patchedCompressedStream);
deltaApplier.HashCheck(deltaReader, patchedCompressedStream);
// Assert
Assert.AreEqual(newFileStreamCompressed.ToArray(), patchedCompressedStream.ToArray());
patchedCompressedStream.Seek(0, SeekOrigin.Begin);
var decompressedStream = new MemoryStream();
using (var gz = new GZipStream(patchedCompressedStream, CompressionMode.Decompress))
{
gz.CopyTo(decompressedStream);
}
var dataOutput = decompressedStream.ToArray();
Assert.AreEqual(newFileStream.ToArray(), dataOutput);
}
static void Main(string[] args)
{
CommandLineApplication commandLineApplication = new CommandLineApplication(throwOnUnexpectedArg: false);
CommandOption basePathArg = commandLineApplication.Option(
"-b |--b <path>",
"Path to base file. ",
CommandOptionType.SingleValue);
CommandOption sigPathArg = commandLineApplication.Option(
"-s |--s <path>",
"Path to signature file. ",
CommandOptionType.SingleValue);
CommandOption newPathArg = commandLineApplication.Option(
"-n |--n <path>",
"Path to new file. ",
CommandOptionType.SingleValue);
CommandOption deltaPathArg = commandLineApplication.Option(
"-d |--d <path>",
"Path to delta file. ",
CommandOptionType.SingleValue);
commandLineApplication.OnExecute(() =>
{
var signatureBaseFilePath = Directory.GetCurrentDirectory();
if (basePathArg.HasValue())
{
if (!File.Exists(basePathArg.Value()))
{
throw new ArgumentException("Path provided does not exist");
}
else
{
signatureBaseFilePath = basePathArg.Value();
}
}
else
{
throw new ArgumentException("Must provide base path.");
}
var signatureFilePath = Directory.GetCurrentDirectory();
if (sigPathArg.HasValue())
{
signatureFilePath = sigPathArg.Value();
}
else
{
throw new ArgumentException("Must provide signature path.");
}
var signatureOutputDirectory = Path.GetDirectoryName(signatureFilePath);
if (!Directory.Exists(signatureOutputDirectory))
{
Directory.CreateDirectory(signatureOutputDirectory);
}
var signatureBuilder = new SignatureBuilder();
using (var basisStream = new FileStream(signatureBaseFilePath, FileMode.Open, FileAccess.Read, FileShare.Read))
using (var signatureStream = new FileStream(signatureFilePath, FileMode.Create, FileAccess.Write, FileShare.Read))
{
signatureBuilder.Build(basisStream, new SignatureWriter(signatureStream));
}
var newFilePath = Directory.GetCurrentDirectory();
if (newPathArg.HasValue())
{
if (!File.Exists(newPathArg.Value()))
{
throw new ArgumentException("Path provided does not exist");
}
else
{
newFilePath = newPathArg.Value();
}
}
else
{
throw new ArgumentException("Must provide new file path.");
}
var deltaFilePath = Directory.GetCurrentDirectory();
if (deltaPathArg.HasValue())
{
deltaFilePath = deltaPathArg.Value();
}
else
{
throw new ArgumentException("Must provide delta path.");
}
var deltaOutputDirectory = Path.GetDirectoryName(deltaFilePath);
if (!Directory.Exists(deltaOutputDirectory))
{
Directory.CreateDirectory(deltaOutputDirectory);
}
var deltaBuilder = new DeltaBuilder();
using (var newFileStream = new FileStream(newFilePath, FileMode.Open, FileAccess.Read, FileShare.Read))
using (var signatureFileStream = new FileStream(signatureFilePath, FileMode.Open, FileAccess.Read, FileShare.Read))
using (var deltaStream = new FileStream(deltaFilePath, FileMode.Create, FileAccess.Write, FileShare.Read))
{
deltaBuilder.BuildDelta(newFileStream, new SignatureReader(signatureFileStream, new ConsoleProgressReporter()), new AggregateCopyOperationsDecorator(new BinaryDeltaWriter(deltaStream)));
}
return(0);
});
commandLineApplication.Execute(args);
}
public Signature ToSDKSignature()
{
SignatureBuilder signatureBuilder = null;
foreach (Silanis.ESL.API.Role role in package.Roles)
{
if (role.Id.Equals(apiApproval.Role))
{
if (isPlaceHolder(role))
{
signatureBuilder = SignatureBuilder.SignatureFor(new Placeholder(role.Id));
}
else if (isGroupRole(role))
{
signatureBuilder = SignatureBuilder.SignatureFor(new GroupId(role.Signers [0].Group.Id));
}
else
{
signatureBuilder = SignatureBuilder.SignatureFor(role.Signers [0].Email);
}
}
}
if (apiApproval.Id != null)
{
signatureBuilder.WithId(new SignatureId(apiApproval.Id));
}
Silanis.ESL.API.Field apiSignatureField = null;
foreach (Silanis.ESL.API.Field apiField in apiApproval.Fields)
{
if (FieldType.SIGNATURE.getApiValue().Equals(apiField.Type))
{
apiSignatureField = apiField;
}
else
{
Field field = new FieldConverter(apiField).ToSDKField();
signatureBuilder.WithField(field);
}
}
if (apiSignatureField == null)
{
signatureBuilder.WithStyle(SignatureStyle.ACCEPTANCE);
signatureBuilder.WithSize(0, 0);
}
else
{
signatureBuilder.WithStyle(new SignatureStyleConverter(apiSignatureField.Subtype).ToSDKSignatureStyle())
.OnPage(apiSignatureField.Page.Value)
.AtPosition(apiSignatureField.Left.Value, apiSignatureField.Top.Value)
.WithSize(apiSignatureField.Width.Value, apiSignatureField.Height.Value);
if (apiSignatureField.Extract.Value)
{
signatureBuilder.WithPositionExtracted();
}
}
Signature signature = signatureBuilder.Build();
if (null != apiApproval.Accepted)
{
signature.Accepted = apiApproval.Accepted;
}
return(signature);
}
private void CalculateSignature(string baseFilePath, string signatureFilePath)
{
using var basisStream = File.OpenRead(baseFilePath);
using var signatureStream = File.OpenWrite(signatureFilePath);
SignatureBuilder.Build(basisStream, new SignatureWriter(signatureStream));
}
