private SignRequest BuildRequest(RequestSignatureType signatureType, DocumentBaseType document, Timestamp previousTimestamp)
{
SignRequest sr = new SignRequest();
ClaimedIdentity identity = new ClaimedIdentity();
identity.idAplicacion = _identity.ApplicationId;
TimestampSignatureType signatureTypeElement = new TimestampSignatureType()
{
Value = signatureType.Uri
};
sr.OptionalInputs = new AnyType();
if (previousTimestamp != null)
{
string renewXml = "<dst:RenewTimestamp xmlns:dst=\"urn:oasis:names:tc:dss:1.0:profiles:TimeStamp:schema#\"><dst:PreviousTimestamp>{0}</dst:PreviousTimestamp></dst:RenewTimestamp>";
XmlElement previousTimestampElement = GetXmlElement(string.Format(renewXml, GetXmlElement(previousTimestamp).OuterXml));
sr.OptionalInputs.Any = new XmlElement[] { GetXmlElement(signatureTypeElement), GetXmlElement(identity), previousTimestampElement };
}
else
{
sr.OptionalInputs.Any = new XmlElement[] { GetXmlElement(signatureTypeElement), GetXmlElement(identity) };
}
sr.InputDocuments = new InputDocuments();
sr.InputDocuments.Items = new object[] { document };
return(sr);
}
public Task <TokenResponse> Sign(SignRequest signRequest)
{
var user = _userRepository.GetByEmail(signRequest.Email);
if (user != null)
{
throw new UnprocessableException("Email ja cadastrado");
}
user = new User
{
Email = signRequest.Email,
Name = signRequest.Name,
Birthday = signRequest.Birthday,
Height = signRequest.Height,
Password = PasswordService.GeneratePassword(signRequest.Password),
CreatedAt = DateTime.UtcNow,
Role = "user"
};
_userRepository.Insert(user);
return(Task.FromResult(new TokenResponse {
Token = JwtService.GetToken(user)
}));
}
public Timestamp RenewTimeStamp(Timestamp previousTimestamp, DocumentBaseType document)
{
if (previousTimestamp == null)
{
throw new ArgumentNullException("previousTimestamp", "El valor no puede ser nulo.");
}
if (document == null)
{
throw new ArgumentNullException("document", "El valor no puede ser nulo.");
}
SignRequest request = BuildRequest(RequestSignatureType.XML, document, previousTimestamp);
RenewTimeSoapClient tsaSoapClient = new RenewTimeSoapClient(_identity, _serverCert);
SignResponse response = tsaSoapClient.renewTimeStamp(request);
if (ResultType.Success.Equals(response.Result.ResultMajor))
{
return(response.SignatureObject.Item as Timestamp);
}
else
{
throw new AfirmaResultException(response.Result.ResultMajor, response.Result.ResultMessage.Value);
}
}
public async Task <ResponseMessage <IActionResult> > SignIn([FromBody] SignRequest request)
{
Logger.Trace($"登陆用户({nameof(SignIn)})，请求参数为：\r\n" + (request != null ? JsonHelper.ToJson(request) : ""));
var response = new ResponseMessage <IActionResult>();
if (!ModelState.IsValid)
{
response.Code = ResponseCodeDefines.ModelStateInvalid;
response.Message = ModelState.GetAllErrors();
Logger.Warn("添加称号模型验证失败：\r\n{0}", response.Message ?? "");
return(response);
}
try
{
return(await UserManager.SignIn(request, HttpContext.RequestAborted));
}
catch (Exception e)
{
response.Code = ResponseCodeDefines.ServiceError;
response.Message = ModelState.GetAllErrors();
Logger.Error($"登陆失败：{e.Message}\r\n{e.StackTrace}");
return(response);
}
}
public async Task SignAsync()
{
byte[] data = Encoding.UTF8.GetBytes("some text");
using (HttpClient httpClient = HttpClientHelper.GetHttpClient(this.serverUri))
{
var workload = new HttpWorkloadClient(httpClient)
{
BaseUrl = HttpClientHelper.GetBaseUrl(this.serverUri)
};
var payload = new SignRequest()
{
Algo = SignRequestAlgo.HMACSHA256,
Data = data,
KeyId = "primary"
};
SignResponse response = await workload.SignAsync(WorkloadApiVersion, "testModule", "1", payload);
string expected;
using (var algorithm = new HMACSHA256(Encoding.UTF8.GetBytes("key")))
{
expected = Convert.ToBase64String(algorithm.ComputeHash(data));
}
Assert.Equal(expected, Convert.ToBase64String(response.Digest));
}
}
public async Task Register()
{
var keySignRequests = new[] { new KeySignRequest(U2FVersion.V2, BROWSER_DATA_SIGN_SHA256, APP_ID_SIGN_SHA256, KEY_HANDLE) };
var keyRegisterRequests = new[] { new KeyRegisterRequest(APP_ID_ENROLL_SHA256, BROWSER_DATA_ENROLL_SHA256) };
keyOperations
.Setup(
x => x.Register(
It.Is <ICollection <KeyRegisterRequest> >(reqs => reqs.SequenceEqual(keyRegisterRequests)),
It.Is <ICollection <KeySignRequest> >(reqs => reqs.SequenceEqual(keySignRequests)),
It.IsAny <CancellationToken>()))
.Returns(
(ICollection <KeyRegisterRequest> registerReqs, ICollection <KeySignRequest> signReqs, CancellationToken ct) =>
Task.FromResult(
RegisterOperationResult.Success(
registerReqs.Single(),
new KeyRegisterResponse(
USER_PUBLIC_KEY_ENROLL_HEX,
KEY_HANDLE,
VENDOR_CERTIFICATE,
SIGNATURE_ENROLL))));
var signRequest = new SignRequest(U2FConsts.U2Fv2, SERVER_CHALLENGE_SIGN_BASE64, APP_ID_SIGN, KEY_HANDLE_BASE64, SESSION_ID);
var registerRequest = new RegisterRequest(U2FConsts.U2Fv2, SERVER_CHALLENGE_ENROLL_BASE64, APP_ID_ENROLL, SESSION_ID);
var result = await u2FClient.Register(new [] { registerRequest }, new[] { signRequest }, CancellationToken.None);
Assert.AreEqual(new RegisterResponse(REGISTRATION_DATA_BASE64, BROWSER_DATA_ENROLL_BASE64, SESSION_ID), result);
}
public Timestamp CreateTimeStamp(RequestSignatureType signatureType, DocumentBaseType document)
{
if (signatureType == null)
{
throw new ArgumentNullException("signatureType", "El valor no puede ser nulo.");
}
if (document == null)
{
throw new ArgumentNullException("document", "El valor no puede ser nulo.");
}
SignRequest request = BuildRequest(signatureType, document, null);
CreateTimeSoapClient tsaSoapClient = new CreateTimeSoapClient(_identity, _serverCert);
SignResponse response = tsaSoapClient.createTimeStamp(request);
if (ResultType.Success.Equals(response.Result.ResultMajor))
{
return(response.SignatureObject.Item as Timestamp);
}
else
{
throw new AfirmaResultException(response.Result.ResultMajor, response.Result.ResultMessage.Value);
}
}
/// <summary>
/// 文件id 验章
/// </summary>
/// <param name="signCheckCommonRequest"></param>
public SignCheckCommonResponse checkCommon(SignCheckCommonRequest signCheckCommonRequest)
{
SignRequest request = new SignRequest(signCheckCommonRequest);
request.apiUrl = ApiUrlConstant.SignCheck.CheckCommon;
return(base.Send <SignCheckCommonResponse>(request));
}
public async Task <IActionResult> GetRequestsForApproval()
{
SetHeaderWithApiToken(_httpClient);
// Get Requests where Status = 0 (Submitted waiting for approval)
var submittedRequest = new HttpRequestMessage(HttpMethod.Get, $"/requests?search=status eq 0");
var submittedResponse = await _httpClient.SendAsync(submittedRequest);
if (submittedResponse.IsSuccessStatusCode)
{
var submittedInfo = submittedResponse.Content.ReadAsStringAsync().Result;
var submittedJsonData = JsonConvert.DeserializeObject <CollectionResponse>(submittedInfo).Value;
List <SignRequest> data = new List <SignRequest>();
foreach (var submitted in submittedJsonData)
{
SignRequest request = new SignRequest(submitted);
data.Add(request);
}
return(Json(data));
}
else
{
return(null);
}
}
public void Sign()
{
SignRequest request = new SignRequest();
request.RoleId = 10001;
client.SendGameMessage(request);
}
public void GetMineWorksAsync(Action <DataResponse <List <UserMineWorkData> >, Exception> callback)
{
SignRequest request = new SignRequest {
};
RpcRoot.SignPostAsync(RpcRoot.OfficialServerHost, RpcRoot.OfficialServerPort, _controllerName, nameof(IUserMineWorkController.MineWorks), data: request, callback, timeountMilliseconds: 2000);
}
/// <summary>
/// Creates a digital signature for a message or message digest by using the private key of a public-private key pair,
/// also known as an asymmetric key. To verify the generated signature, you can use the [Verify](https://docs.cloud.oracle.com/api/#/en/key/latest/VerifiedData/Verify)
/// operation. Or, if you want to validate the signature outside of the service, you can do so by using the public key of the same asymmetric key.
///
/// </summary>
/// <param name="request">The request object containing the details to send. Required.</param>
/// <param name="retryConfiguration">The retry configuration that will be used by to send this request. Optional.</param>
/// <param name="cancellationToken">The cancellation token to cancel this operation. Optional.</param>
/// <returns>A response object containing details about the completed operation</returns>
/// <example>Click <a href="https://docs.cloud.oracle.com/en-us/iaas/tools/dot-net-examples/latest/keymanagement/Sign.cs.html">here</a> to see an example of how to use Sign API.</example>
public async Task <SignResponse> Sign(SignRequest request, RetryConfiguration retryConfiguration = null, CancellationToken cancellationToken = default)
{
logger.Trace("Called sign");
Uri uri = new Uri(this.restClient.GetEndpoint(), System.IO.Path.Combine(basePathWithoutHost, "/20180608/sign".Trim('/')));
HttpMethod method = new HttpMethod("POST");
HttpRequestMessage requestMessage = Converter.ToHttpRequestMessage(uri, method, request);
requestMessage.Headers.Add("Accept", "application/json");
GenericRetrier retryingClient = Retrier.GetPreferredRetrier(retryConfiguration, this.retryConfiguration);
HttpResponseMessage responseMessage;
try
{
if (retryingClient != null)
{
responseMessage = await retryingClient.MakeRetryingCall(this.restClient.HttpSend, requestMessage, cancellationToken).ConfigureAwait(false);
}
else
{
responseMessage = await this.restClient.HttpSend(requestMessage).ConfigureAwait(false);
}
this.restClient.CheckHttpResponseMessage(requestMessage, responseMessage);
return(Converter.FromHttpResponseMessage <SignResponse>(responseMessage));
}
catch (Exception e)
{
logger.Error($"Sign failed with error: {e.Message}");
throw;
}
}
public void SignRequestSerial(SignRequest request)
{
if (string.IsNullOrWhiteSpace(Const.Locator.ParameterSetting.SelectedPort))
{
throw new Exception("Port can not be null.");
}
if (string.IsNullOrWhiteSpace(Const.Locator.ParameterSetting.SelectedDataBits))
{
throw new Exception("DataBits can not be null.");
}
if (string.IsNullOrWhiteSpace(Const.Locator.ParameterSetting.SelectedBaudRate))
{
throw new Exception("BaudRate can not be null.");
}
if (string.IsNullOrWhiteSpace(Const.Locator.ParameterSetting.SelectedParity))
{
throw new Exception("Parity can not be null.");
}
if (string.IsNullOrWhiteSpace(Const.Locator.ParameterSetting.SelectedStopBits))
{
throw new Exception("StopBits can not be null.");
}
string requestString = JsonConvert.SerializeObject(request);
SerialClient _client = new SerialClient(Const.Locator.ParameterSetting.SelectedPort,
int.Parse(Const.Locator.ParameterSetting.SelectedBaudRate),
(Parity)Enum.Parse(typeof(Parity), Const.Locator.ParameterSetting.SelectedParity),
int.Parse(Const.Locator.ParameterSetting.SelectedDataBits),
(StopBits)Enum.Parse(typeof(StopBits), Const.Locator.ParameterSetting.SelectedStopBits));
_client.Open();
_client.Complated -= _signTcpClient_Complated;
_client.Complated += _signTcpClient_Complated;
_client.Send(0x02, requestString);
}
public async Task <IActionResult> SignUsingAuthenticode(SignRequest request)
{
var(token, tokenConfig, tokenError) = _utils.TryGetAccessToken(request);
if (tokenError != null)
{
return(tokenError);
}
var secretKey = _secretStorage.LoadSecret(token.KeyName, token.Code);
var(artifact, artifactError, fileExtension) = await _utils.GetFileFromPayloadAsync(token, tokenConfig, request);
if (artifactError != null)
{
return(artifactError);
}
var signed = _signer.Sign(
artifact,
Path.GetFileNameWithoutExtension(token.KeyName),
secretKey,
token.KeyFingerprint
);
return(File(signed, "application/pgp-signature"));
}
public async Task Sign()
{
var keySignRequests = new[]
{
new KeySignRequest(U2FVersion.V2, BROWSER_DATA_SIGN_SHA256, APP_ID_SIGN_SHA256, KEY_HANDLE)
};
keyOperations
.Setup(
x => x.Sign(
It.Is <ICollection <KeySignRequest> >(reqs => reqs.SequenceEqual(keySignRequests)),
It.IsAny <CancellationToken>(),
false))
.Returns(
(ICollection <KeySignRequest> reqs, CancellationToken ct, bool individualAttest) =>
Task.FromResult(
SignOperationResult.Success(
reqs.Single(),
new KeySignResponse(
UserPresenceVerifierConstants.UserPresentFlag,
COUNTER_VALUE,
SIGNATURE_AUTHENTICATE))));
var signRequest = new SignRequest(U2FConsts.U2Fv2, SERVER_CHALLENGE_SIGN_BASE64, APP_ID_SIGN, KEY_HANDLE_BASE64, SESSION_ID);
var result = await u2FClient.Sign(new[] { signRequest }, CancellationToken.None);
Assert.AreEqual(new SignResponse
(BROWSER_DATA_SIGN_BASE64, SIGN_RESPONSE_DATA_BASE64, SERVER_CHALLENGE_SIGN_BASE64
, SESSION_ID, APP_ID_SIGN), result);
}
public void SignRequest(SignRequest request)
{
if (request == null)
{
throw new ArgumentNullException("SignRequest data can not be null.");
}
_signTcpClient = new TcpHelper();
if (string.IsNullOrWhiteSpace(Const.Locator.ParameterSetting.SdcUrl))
{
MessageBoxEx.Show("EFD URL can not be null.", MessageBoxButton.OK);
return;
}
string[] sdc = Const.Locator.ParameterSetting.SdcUrl.Split(':');
if (sdc != null && sdc.Count() != 2)
{
MessageBoxEx.Show("EFD URL is not in the right format.", MessageBoxButton.OK);
return;
}
bool isConn = _signTcpClient.Connect(IPAddress.Parse(sdc[0]), int.Parse(sdc[1]));
if (!isConn)
{
MessageBoxEx.Show("Failed to connect to EFD.", MessageBoxButton.OK);
return;
}
string requestString = JsonConvert.SerializeObject(request);
_signTcpClient.Complated -= _signTcpClient_Complated;
_signTcpClient.Complated += _signTcpClient_Complated;
_signTcpClient.Send(0x02, requestString);
_signTcpClient.ReciveAsync();
}
public string SignPhysician(SignRequest request)
{
PatientChain patientChain = new PatientChain();
var Signature = patientChain.SignMessage(request.HashPrivateKey, request.PhysicianId);
return("{ \"Signature\" : \"" + Signature + "\" }");
}
/// <summary>
/// 原始调用Paas Api接口
/// </summary>
public void callApi()
{
//初始化请求参数，请参考API文档
SignRequest request = new SignRequest();
//请求API接口地址
request.apiUrl = "/v1/seal/query";
//请求API参数
Dictionary <string, object> requestBody = new Dictionary <string, object>();
requestBody.Add("seal_id", "051a3ebaa027d6bd530c2724b97c518c");
request.requestBody = requestBody;
try
{
Dictionary <string, object> response = client.Send <Dictionary <string, object> >(request);
Console.WriteLine("原始调用Paas-Api接口-响应数据：" + JSONUtil.getJsonStringFromObject(response));
}
catch (SignApplicationException sae)
{
// 捕获网关校验数据
Console.WriteLine("原始调用Paas-Api接口-网关异常状态码为：" + sae.return_code);
Console.WriteLine("原始调用Paas-Api接口-网关异常信息为：" + sae.return_message);
}
catch (SignServerException sse)
{
// 捕获网关校验数据
Console.WriteLine("原始调用Paas-Api接口-业务异常状态码为：" + sse.result_code);
Console.WriteLine("原始调用Paas-Api接口-业务异常信息为：" + sse.result_message);
}
}
private void SignByPlatform(long contractId, List <long> documents)
{
SignRequest request = new SignRequest();
request.acrossPage = true;
request.contractId = contractId;
List <StandardSignStamper> stampers = new List <StandardSignStamper>();
StandardSignStamper stamper = new StandardSignStamper();
stamper.documentId = documents[0];
stamper.page = 1;
stamper.offsetX = 0.1;
stamper.offsetY = 0.2;
stamper.type = StandardSignType.SEAL;
stamper.sealId = 1234567890;
stampers.Add(stamper);
request.stampers = stampers;
try
{
signService.Sign(request);
Console.WriteLine("平台签署成功！");
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// 保存token
/// </summary>
/// <returns></returns>
private Token saveToken()
{
// body 体
TokenRequest tokenRequest = new TokenRequest();
tokenRequest.app_id = this.appId;
tokenRequest.app_secret = this.appSecret;
// 创建 请求对象
SignRequest request = new SignRequest(tokenRequest);
request.apiUrl = ApiUrlConstant.Token.GetToken;
request.contentType = ContentType.JSON;
request.needSign = false;
request.needToken = false;
request.httpMethod = HttpMethod.POST;
// 发送请求
TokenResponse res = Send <TokenResponse>(request);
// 创建业务对象
Token token = new Token();
token.access_token = res.access_token;
token.expires_in = res.expires_in;
token.scopy = res.scopy;
token.token_type = res.token_type;
// 放入token 存储池
tokenDataSource.deleteToken(this.appId);
tokenDataSource.setToken(this.appId, token);
return(token);
}
protected void Page_Load(object sender, EventArgs e)
{
id = RequestData.Get <string>("id");
if (!string.IsNullOrEmpty(id))
{
ent = SignRequest.Find(id);
}
switch (RequestActionString)
{
case "delete":
if (!string.IsNullOrEmpty(ent.Attachment))
{
foreach (string str in ent.Attachment.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries))
{
FileItem fiEnt = FileItem.Find(str);
fiEnt.DoDelete();
}
}
ent.DoDelete();
break;
case "submit":
StartFlow();
break;
case "AutoExecuteFlow":
AutoExecuteFlow();
break;
default:
DoSelect();
break;
}
}
/// <summary>
/// 获取用户Token
/// </summary>
/// <returns></returns>
public async Task <Newtonsoft.Json.Linq.JObject> GetUserTokenObject(SignRequest request)
{
string tokenUrl = Configuration["AuthUrl"];
HttpClient client = new HttpClient
{
BaseAddress = new Uri(tokenUrl)
};
var parameters = new Dictionary <string, string>
{
{ "username", request.LoginName },
{ "password", request.Password },
{ "grant_type", "password" }, //密码模式
{ "client_id", Configuration["ClientID"] },
{ "client_secret", Configuration["ClientSecret"] } //密钥
};
client.DefaultRequestHeaders.Add("ReqHeader", "{\"source\":3}");
//Logger.Info("C端小程序用户登录" + JsonHelper.ToJson(client));
//获取token
HttpResponseMessage tokenResponse = await client.PostAsync("/connect/token", new System.Net.Http.FormUrlEncodedContent(parameters));
//Logger.Info($"小程序虚拟账号登录请求相应：{JsonHelper.ToJson(tokenResponse)}");
if (tokenResponse?.StatusCode == System.Net.HttpStatusCode.OK)
{
var jObj = JsonHelper.ToObject <Newtonsoft.Json.Linq.JObject>(await tokenResponse.Content.ReadAsStringAsync());
return(jObj);
}
return(new Newtonsoft.Json.Linq.JObject());
}
public async Task <ActionResult> Sign(string id, [FromBody] SignRequest request)
{
var signed = await enclave.Sign(enclave.ParseKeyId(id), request.Value);
return(Ok(new SignResult {
Value = signed
}));
}
public IEnumerator Sign()
{
SignRequest request = new SignRequest();
request.RoleId = 10001;
client.SendGameMessage(request);
yield return(new WaitForSeconds(4));
}
public ResponseBase RestartWindows(string clientIp, SignRequest request)
{
using (HttpClient client = RpcRoot.CreateHttpClient()) {
Task <HttpResponseMessage> getHttpResponse = client.PostAsJsonAsync($"http://{clientIp}:{NTKeyword.NTMinerDaemonPort.ToString()}/api/{_controllerName}/{nameof(INTMinerDaemonController.RestartWindows)}", request);
ResponseBase response = getHttpResponse.Result.Content.ReadAsAsync <ResponseBase>().Result;
return(response);
}
}
/// <summary>
/// 模板锁定接口
/// </summary>
/// <param name="templateLockRequest"></param>
/// <returns></returns>
public TemplateLockResponse templateLock(TemplateLockRequest templateLockRequest)
{
SignRequest signRequest = new SignRequest(templateLockRequest);
signRequest.apiUrl = ApiUrlConstant.Template.Lock;
TemplateLockResponse response = this.Send <TemplateLockResponse>(signRequest);
return(response);
}
/// <summary>
/// 模板删除接口
/// </summary>
/// <param name="templateDelRequest"></param>
/// <returns></returns>
public TemplateDelResponse remove(TemplateDelRequest templateDelRequest)
{
SignRequest signRequest = new SignRequest(templateDelRequest);
signRequest.apiUrl = ApiUrlConstant.Template.Delete;
TemplateDelResponse response = this.Send <TemplateDelResponse>(signRequest);
return(response);
}
/// <summary>
/// 模板添加接口
/// </summary>
/// <param name="sealAddRequest"></param>
/// <returns></returns>
public TemplateAddResponse add(TemplateAddRequest templateAddRequest)
{
SignRequest signRequest = new SignRequest(templateAddRequest);
signRequest.apiUrl = ApiUrlConstant.Template.Add;
TemplateAddResponse response = this.Send <TemplateAddResponse>(signRequest);
return(response);
}
/// <summary>
/// 模板查询接口
/// </summary>
/// <param name="templateQueryRequest"></param>
/// <returns></returns>
public TemplateQueryResponse query(TemplateQueryRequest templateQueryRequest)
{
SignRequest signRequest = new SignRequest(templateQueryRequest);
signRequest.apiUrl = ApiUrlConstant.Template.Query;
TemplateQueryResponse response = this.Send <TemplateQueryResponse>(signRequest);
return(response);
}
public void LoginAsync(string loginName, string password, Action <ResponseBase, Exception> callback)
{
VirtualRoot.SetRpcUser(new User.RpcUser(loginName, password));
SignRequest request = new SignRequest()
{
};
RpcRoot.PostAsync(NTMinerRegistry.GetControlCenterHost(), NTKeyword.ControlCenterPort, _controllerName, nameof(IControlCenterController.LoginControlCenter), request, request, callback);
}
/// <remarks/>
public void DssSignAsync(SignRequest SignRequest, object userState) {
if ((this.DssSignOperationCompleted == null)) {
this.DssSignOperationCompleted = new System.Threading.SendOrPostCallback(this.OnDssSignOperationCompleted);
}
this.InvokeAsync("DssSign", new object[] {
SignRequest}, this.DssSignOperationCompleted, userState);
}
//'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
//Sign PDF file
public bool SignPDFFile(
string FileToSign,
string UserName,
string Password,
int X,
int Y,
int Width,
int Height,
int Page,
bool isVisible)
{
//Create Request object contains signature parameters
RequestBaseType Req = new RequestBaseType();
Req.OptionalInputs = new RequestBaseTypeOptionalInputs();
//Here Operation Type is set: Verify/Create Signature Field/Sign/etc
Req.OptionalInputs.SignatureType = SignatureTypeFieldCreateSign;
//Configure Create and Sign operation parameters:
Req.OptionalInputs.ClaimedIdentity = new ClaimedIdentity();
Req.OptionalInputs.ClaimedIdentity.Name = new NameIdentifierType();
Req.OptionalInputs.ClaimedIdentity.Name.Value = UserName; //User Name
Req.OptionalInputs.ClaimedIdentity.Name.NameQualifier = " "; //Domain (relevant for Active Directory environment only)
Req.OptionalInputs.ClaimedIdentity.SupportingInfo = new CoSignAuthDataType();
Req.OptionalInputs.ClaimedIdentity.SupportingInfo.LogonPassword = Password; //User Password
Req.OptionalInputs.SAPISigFieldSettings = new SAPISigFieldSettingsType();
Req.OptionalInputs.SAPISigFieldSettings.X = X; //Signature Field X coordinate
Req.OptionalInputs.SAPISigFieldSettings.XSpecified = true;
Req.OptionalInputs.SAPISigFieldSettings.Y = Y; //Signature Field Y coordinate
Req.OptionalInputs.SAPISigFieldSettings.YSpecified = true;
Req.OptionalInputs.SAPISigFieldSettings.Page = Page; //Page number the signature field will appear on
Req.OptionalInputs.SAPISigFieldSettings.PageSpecified = true;
Req.OptionalInputs.SAPISigFieldSettings.Width = Width; //Signature Field width
Req.OptionalInputs.SAPISigFieldSettings.WidthSpecified = true;
Req.OptionalInputs.SAPISigFieldSettings.Height = Height; //Signature Field Height
Req.OptionalInputs.SAPISigFieldSettings.HeightSpecified = true;
Req.OptionalInputs.SAPISigFieldSettings.Invisible = !isVisible; //Specifies whether the signature will be visible or not
Req.OptionalInputs.SAPISigFieldSettings.InvisibleSpecified = true;
// Set configuration parameters /////////////////////////////////////////////////////////
int numConfigurationParams = 6;
Req.OptionalInputs.ConfigurationValues = new ConfValueType[numConfigurationParams];
for (int i = 0; i < numConfigurationParams; i++)
{
Req.OptionalInputs.ConfigurationValues[i] = new ConfValueType();
}
// Add reason
Req.OptionalInputs.ConfigurationValues[0].ConfValueID = ConfIDEnum.Reason;
Req.OptionalInputs.ConfigurationValues[0].Item = "I am the author of this document";
// Add TSA:
/*
Req.OptionalInputs.ConfigurationValues[1].ConfValueID = ConfIDEnum.UseTimestamp;
Req.OptionalInputs.ConfigurationValues[1].Item = 1;
Req.OptionalInputs.ConfigurationValues[2].ConfValueID = ConfIDEnum.TimestampURL;
Req.OptionalInputs.ConfigurationValues[2].Item = "http://www.ca-soft.com/request.aspx";
Req.OptionalInputs.ConfigurationValues[3].ConfValueID = ConfIDEnum.TimestampAdditionalBytes;
Req.OptionalInputs.ConfigurationValues[3].Item = 4000;
Req.OptionalInputs.ConfigurationValues[4].ConfValueID = ConfIDEnum.TimestampUser;
Req.OptionalInputs.ConfigurationValues[4].Item = "";
Req.OptionalInputs.ConfigurationValues[5].ConfValueID = ConfIDEnum.TimestampPWD;
Req.OptionalInputs.ConfigurationValues[5].Item = "";
// OCSP (NOTE: Server must contain comodo CA in order to use the following OCSP URL)
Req.OptionalInputs.ConfigurationValues[4].ConfValueID = ConfIDEnum.UseOCSP;
Req.OptionalInputs.ConfigurationValues[4].Item = 1;
Req.OptionalInputs.ConfigurationValues[5].ConfValueID = ConfIDEnum.OCSPURL;
Req.OptionalInputs.ConfigurationValues[5].Item = "ocsp.comodoca.com";
*/
// End setting configuration parameters ////////////////////////////////////////////////
//Set Session ID
Req.RequestID = Guid.NewGuid().ToString();
//Prepare the Data to be signed
DocumentType doc1 = new DocumentType();
DocumentTypeBase64Data b64data = new DocumentTypeBase64Data();
Req.InputDocuments = new RequestBaseTypeInputDocuments();
Req.InputDocuments.Items = new object[1];
b64data.MimeType = "application/pdf"; //Can also be: application/msword, image/tiff, pplication/octet-string (ocsp/tsa are supported in PDF only)
Req.OptionalInputs.ReturnPDFTailOnlySpecified = true;
Req.OptionalInputs.ReturnPDFTailOnly = true;
b64data.Value = ReadFile(FileToSign, true); //Read the file to the Bytes Array
doc1.Item = b64data;
Req.InputDocuments.Items[0] = doc1;
//Call sign service
ResponseBaseType Resp = null;
try
{
// Create the Web Service client object
DSS service = new DSS();
service.Url = "https://prime.cosigntrial.com:8080/SAPIWS/dss.asmx"; //This url is constant and shouldn't be changed
SignRequest sreq = new SignRequest();
sreq.InputDocuments = Req.InputDocuments;
sreq.OptionalInputs = Req.OptionalInputs;
//Perform Signature operation
Resp = service.DssSign(sreq);
if (Resp.Result.ResultMajor != Success )
{
MessageBox.Show("Error: " + Resp.Result.ResultMajor + " " +
Resp.Result.ResultMinor + " " +
Resp.Result.ResultMessage.Value, "Error");
return false;
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error");
if (ex is WebException)
{
WebException we = ex as WebException;
WebResponse webResponse = we.Response;
if (webResponse != null)
MessageBox.Show(we.Response.ToString(), "Web Response");
}
return false;
}
//Handle Reply
DssSignResult sResp = (DssSignResult) Resp;
//object sig = sResp.SignatureObject.Item;
//SignatureObjectTypeBase64Signature sig = (SignatureObjectTypeBase64Signature) sResp.SignatureObject.Item;
DssSignResultSignatureObjectBase64Signature sig = (DssSignResultSignatureObjectBase64Signature)sResp.SignatureObject.Item;
byte[] signature = sig.Value;
return PDFAttachSignature(FileToSign, signature, true); //Attach Signature to the PDF file
}
static void Main(string[] args)
{
// Custom Values
string filePath = "c:/temp/demo.pdf"; // File to sign
string fileMimeType = "application/pdf"; // File MIME type
string username = "******"; // CoSign account username
string password = "******"; // CoSign account password
string domain = ""; // CoSign account domain
int sigPageNum = 1; // Create signature on the first page
int sigX = 145; // Signature field X location
int sigY = 125; // Signature field Y location
int sigWidth = 160; // Signature field width
int sigHeight = 45; // Signature field height
string timeFormat = "hh:mm:ss"; // The display format of the time
string dateFormat = "dd/MM/yyyy"; // The display format of the date
uint appearanceMask = 11; // Elements to display on the signature field (11 = Graphical image + Signer name + Time)
string signatureType = "http://arx.com/SAPIWS/DSS/1.0/signature-field-create-sign"; // The actual operation of the Sign Request function
string wsdlUrl = "https://prime.cosigntrial.com:8080/sapiws/dss.asmx?WSDL"; // URL to the WSDL file
try
{
// Read file contents
byte[] fileBuffer = File.ReadAllBytes(filePath);
// Set file contents + MIME type (the SOAP library automatically base64 encodes the data)
DocumentType document = new DocumentType()
{
Item = new DocumentTypeBase64Data()
{
Value = fileBuffer,
MimeType = fileMimeType
}
};
ClaimedIdentity claimedIdentity = new ClaimedIdentity()
{
Name = new NameIdentifierType()
{
Value = username,
NameQualifier = domain
},
SupportingInfo = new CoSignAuthDataType()
{
LogonPassword = password
}
};
// Define signature field settings
SAPISigFieldSettingsType sigFieldSettings = new SAPISigFieldSettingsType()
{
Invisible = false,
InvisibleSpecified = true,
X = sigX,
XSpecified = true,
Y = sigY,
YSpecified = true,
Width = sigWidth,
WidthSpecified = true,
Height = sigHeight,
HeightSpecified = true,
Page = sigPageNum,
PageSpecified = true,
AppearanceMask = appearanceMask,
AppearanceMaskSpecified = true,
TimeFormat = new TimeDateFormatType()
{
TimeFormat = timeFormat,
DateFormat = dateFormat,
ExtTimeFormat = ExtendedTimeFormatEnum.GMT,
ExtTimeFormatSpecified = true
}
};
// Build complete request object
SignRequest signRequest = new SignRequest()
{
InputDocuments = new RequestBaseTypeInputDocuments()
{
Items = new DocumentType[] { document }
},
OptionalInputs = new RequestBaseTypeOptionalInputs()
{
SignatureType = signatureType,
ClaimedIdentity = claimedIdentity,
SAPISigFieldSettings = sigFieldSettings,
ReturnPDFTailOnly = true,
ReturnPDFTailOnlySpecified = true
}
};
// Initiate service client
DSS client = new DSS() { Url = wsdlUrl };
// Send the request
DssSignResult response = client.DssSign(signRequest);
// Check response output
if ("urn:oasis:names:tc:dss:1.0:resultmajor:Success".Equals(response.Result.ResultMajor))
{
// On success- append signature object to the source PDF document (the SOAP library automatically decodes the base64 encoded output)
byte[] signatureObjectBuffer = ((DssSignResultSignatureObjectBase64Signature)response.SignatureObject.Item).Value;
using (var fileStream = new FileStream(filePath, FileMode.Append))
{
fileStream.Write(signatureObjectBuffer, 0, signatureObjectBuffer.Length);
}
}
else
{
// On failure- raise exception with the result error message
throw new Exception(response.Result.ResultMessage.Value);
}
Console.WriteLine("The document has been successfully signed!");
}
catch (Exception e)
{
Console.WriteLine("Error: " + e.Message);
}
}
protected bool Equals(SignRequest other)
{
return string.Equals(Version, other.Version) && string.Equals(Challenge, other.Challenge) &&
string.Equals(AppId, other.AppId) && string.Equals(KeyHandle, other.KeyHandle) &&
string.Equals(SessionId, other.SessionId);
}
public StorageInfoDO Store(byte[] documentData, String contentType)
{
Console.WriteLine("Store");
// setup the client
SetupClient();
// create SignRequest
String requestId = "dss-sign-request-" + Guid.NewGuid().ToString();
SignRequest signRequest = new SignRequest();
signRequest.RequestID = requestId;
signRequest.Profile = DSSConstants.ARTIFACT_NAMESPACE;
// add "ReturnStorageInfo" optional input
AnyType optionalInputs = new AnyType();
XmlElement returnStorageInfoElement = GetElement("artifact", "ReturnStorageInfo", DSSConstants.ARTIFACT_NAMESPACE);
optionalInputs.Any = new XmlElement[] { returnStorageInfoElement };
signRequest.OptionalInputs = optionalInputs;
// add document
signRequest.InputDocuments = GetInputDocuments(documentData, contentType);
// operate
SignResponse signResponse = client.sign(signRequest);
// parse response
CheckResponse(signResponse, requestId);
try
{
ValidateResult(signResponse);
}
catch (NotParseableXMLDocumentException e)
{
throw new SystemException(e.Message, e);
}
// check profile
if (!signResponse.Profile.Equals(DSSConstants.ARTIFACT_NAMESPACE))
{
throw new SystemException("Unexpected SignResponse.Profile: " + signResponse.Profile);
}
// parse StorageInfo
DSSXSDNamespace.StorageInfo storageInfo = FindStorageInfo(signResponse);
if (null == storageInfo)
{
throw new SystemException("Missing StorageInfo");
}
return new StorageInfoDO(storageInfo.Identifier, storageInfo.Validity.NotBefore, storageInfo.Validity.NotAfter);
}
public byte[] Retrieve(String documentId)
{
Console.WriteLine("Retrieve");
// setup client
SetupClient();
// create request
String requestId = "dss-sign-request-" + Guid.NewGuid().ToString();
SignRequest signRequest = new SignRequest();
signRequest.RequestID = requestId;
signRequest.Profile = DSSConstants.ARTIFACT_NAMESPACE;
// add "ReturnStoredDocument" optional input
AnyType optionalInputs = new AnyType();
DSSXSDNamespace.ReturnStoredDocument returnStoredDocument = new DSSXSDNamespace.ReturnStoredDocument();
returnStoredDocument.Identifier = documentId;
XmlElement returnStoredDocumentElement = ToDom("ReturnStoredDocument", DSSConstants.ARTIFACT_NAMESPACE,
returnStoredDocument, typeof(DSSXSDNamespace.ReturnStoredDocument));
optionalInputs.Any = new XmlElement[] { returnStoredDocumentElement };
signRequest.OptionalInputs = optionalInputs;
// operate
SignResponse signResponse = this.client.sign(signRequest);
// parse response
CheckResponse(signResponse, requestId);
try
{
ValidateResult(signResponse);
}
catch (NotParseableXMLDocumentException e)
{
throw new SystemException(e.Message, e);
}
// check profile
if (!signResponse.Profile.Equals(DSSConstants.ARTIFACT_NAMESPACE))
{
throw new SystemException("Unexpected SignResponse.Profile: " + signResponse.Profile);
}
// get document
DSSXSDNamespace.DocumentWithSignature documentWithSignature = FindDocumentWithSignature(signResponse);
if (null == documentWithSignature || null == documentWithSignature.Document || null == documentWithSignature.Document.Item)
{
throw new DocumentNotFoundException();
}
byte[] documentData;
if (documentWithSignature.Document.Item is DSSXSDNamespace.Base64Data)
{
documentData = ((DSSXSDNamespace.Base64Data)documentWithSignature.Document.Item).Value;
}
else
{
documentData = (byte[])documentWithSignature.Document.Item;
}
return documentData;
}
/// <remarks/>
public void DssSignAsync(SignRequest SignRequest) {
this.DssSignAsync(SignRequest, null);
}
