private static StatusInfo Extract(ArgsInfo arguments)
{
StatusInfo si;
try
{
si = new StatusInfo(
new ResultInfo(
_serializer.CertificateToSerializable(
arguments.CertificateSource,
arguments.InputFile,
arguments.NodeId)
)
);
}
catch (Exception e)
{
si = new StatusInfo(
new ErrorInfo(
ErrorCodes.CertificateExtractionException,
ErrorType.CertificateExtraction,
e.Message));
}
return(si);
}
/// <summary>
/// Initializes a new instance of the Procedure class, setting min and max args.
/// </summary>
/// <param name="name">The procedure name.</param>
/// <param name="argsInfo">Information about primitive args.</param>
protected Procedure(string name, ArgsInfo argsInfo)
{
this.procedureName = name;
this.minArgs = argsInfo.MinArgs;
this.maxArgs = argsInfo.MaxArgs;
this.unevaluated = argsInfo.Unevaluated;
}
private static StatusInfo Verify(ArgsInfo arguments)
{
try
{
var verifierResult = _verifier.VerifySignature(
arguments.SigType,
arguments.InputFile,
arguments.CertificateLocation == CertificateLocation.CerFile
? arguments.CertificateFilePath
: null,
arguments.CertificateLocation == CertificateLocation.Thumbprint
? arguments.CertificateThumbprint
: null,
arguments.NodeId,
isVerifyCertificateChain: arguments.IsVerifyCertificateChain
);
return(verifierResult.IsSignatureMathematicallyValid && verifierResult.IsSignatureSigningDateValid
? new StatusInfo(new ResultInfo("Signature is correct", true))
: new StatusInfo(new ResultInfo("Signature is invalid", false)));
}
catch (Exception e)
{
return(new StatusInfo(new ErrorInfo(ErrorCodes.VerificationFailed, ErrorType.SignatureVerification, e.Message)));
}
}
public static StatusInfo MainCore(ArgsInfo arguments)
{
if (arguments.Ok)
{
switch (arguments.Function)
{
case ProgramFunction.Sign:
return(Sign(arguments));
case ProgramFunction.Verify:
return(Verify(arguments));
case ProgramFunction.Extract:
return(Extract(arguments));
case ProgramFunction.VerifyAndExtract:
return(VerifyAndExtract(arguments));
case ProgramFunction.Describe:
return(DescribeCertificate(arguments));
}
}
return(new StatusInfo(arguments.InitError));
}
private static StatusInfo DescribeCertificate(ArgsInfo arguments)
{
var certificateBytes = File.ReadAllBytes(arguments.InputFile);
var readCertificate = _processor.ReadCertificateFromCertificateFile(certificateBytes);
var serializedCertificate = _serializer.CertificateToSerializable(readCertificate);
return(new StatusInfo(new ResultInfo(serializedCertificate)));
}
private async Task <ApiInputParameters> ReadInputParameters(HttpRequestMessage request, string command)
{
var clientDisconnectedCancellationToken =
request.GetOwinContext()?.Request?.CallCancelled ?? CancellationToken.None;
//NOTE: this is not an in-memory way of doing the same thing
//var root = HttpContext.Current.Server.MapPath("~/App_Data/");
//var streamProvider = new MultipartFormDataStreamProvider(root);
var streamProvider = new InMemoryMultipartFormDataStreamProvider();
await request.Content.ReadAsMultipartAsync(streamProvider, clientDisconnectedCancellationToken);
var querySegments = request.RequestUri.ParseQueryString();
List <string> args = new()
{
command
};
foreach (var key in querySegments.AllKeys)
{
var value = querySegments[key];
args.Add($"-{key}={value}");
}
ArgsInfo argsInfo = ArgsInfo.Parse(args.ToArray(), true, _settings.Signer.KnownThumbprints);
var dataToSign = await ReadInputFile(streamProvider, ApiInputFileContants.DataToSignFileFormFieldName);
if (dataToSign == null &&
argsInfo.Function != ProgramFunction.Describe)
{
Log.Error("File to sign is not found");
}
var signatureBytes = await ReadInputFile(streamProvider, ApiInputFileContants.SignatureFileFormFieldName);
var certificateBytes = await ReadInputFile(
streamProvider,
ApiInputFileContants.CertificateFileFormFieldName);
ApiInputParameters ret = new()
{
ArgsInfo = argsInfo,
DataToSign = dataToSign,
SignatureFileBytes = signatureBytes,
CertificateFileBytes = certificateBytes
};
return(ret);
}
private static StatusInfo VerifyAndExtract(ArgsInfo arguments)
{
StatusInfo si = Verify(arguments);
if (!si.IsError)
{
if (si.Result.SignatureIsCorrect.HasValue && si.Result.SignatureIsCorrect.Value)
{
arguments.CertificateSource = CertificateSource.Xml;
si = Extract(arguments);
}
}
return(si);
}
private static StatusInfo Sign(ArgsInfo arguments)
{
try
{
string signedData = _signer.Sign(
arguments.SigType,
arguments.GostFlavor,
arguments.CertificateThumbprint,
arguments.InputFile,
arguments.AssignDsInSignature,
arguments.NodeId,
arguments.IgnoreExpiredCertificate,
arguments.IsAddSigningTime);
File.WriteAllText(arguments.OutputFile, signedData);
return(new StatusInfo($"OK. Signed file path: {arguments.OutputFile}"));
}
catch (Exception e)
{
return(new StatusInfo(new ErrorInfo(ErrorCodes.SigningFailed, ErrorType.Signing, $"{e.Message}")));
}
}
private static void Main(string[] args)
{
if (args.Length <= 0)
{
ShowHelp();
return;
}
if (args[0] == @"\?" || args[0] == @"?" || args[0] == "help")
{
ShowHelp();
return;
}
var configuration = GetConfiguration();
InitializeLogger(configuration);
WebApiHost = new WebApiHost(configuration);
if (args[0] == "api")
{
ConfigureService(string.Empty);
}
if (args[0] == "install" ||
args[0] == "uninstall")
{
ConfigureService(args[0]);
return;
}
ArgsInfo inputArguments = ArgsInfo.Parse(args, false, configuration.Signer.KnownThumbprints);
var statusInfo = MainCore(inputArguments);
Console.WriteLine(statusInfo.ToJsonString());
}
