public static ResultArgs ReadSector(int sector, M1KeyMode keyMode, byte[] key) { ICardReader cardReader = ContextManager.GetCardReader(); ResultArgs ret = cardReader.Select(); if (!ret.Succ) { return(new ResultArgs(false, null, "Select Card Error!")); } CardSelectResult info = (CardSelectResult)ret.Result; logger.Debug(String.Format("Select card_id={0}, ATQA=0x{1}, SAK={2}", BitConverter.ToString(info.SN), info.ATQA.ToString("X4"), info.SAK.ToString("X2"))); if (!cardReader.Authen(keyMode, sector * 4, key)) { logger.Debug(String.Format("Auth sector {0} failed !", sector)); return(new ResultArgs(false, null, "Auth sector failed !")); } byte[] buffer; int len = 0; if (!cardReader.ReadSector(sector, out buffer, out len)) { return(new ResultArgs(false, null, "Read sector failed !")); } return(new ResultArgs(true, BitConverter.ToString(buffer), "OK")); }
public ResultArgs ExecuteAsScripts(string sSQL) { ResultArgs result = new ResultArgs(); try { connection = OpenConnection(); //var script = new (connection, sSQL); //var resultScript = script.Execute(); result.Success = true; //result.RowsAffected = resultScript; } catch (Exception e) { result.Exception = e; result.Success = false; using (ErrorLog objlog = new ErrorLog()) { objlog.WriteError("Error Handler", "FetchData(DataValue,string)", sSQL, e.Message); } CloseConnection(); } finally { CloseConnection(); } return(result); #endregion }
private void SetRowUniqueIdentifierValue(ResultArgs result, OracleCommand OracleCommand) { if (OracleCommand.CommandType == CommandType.StoredProcedure) { OracleParameterCollection OracleParameterCollection = OracleCommand.Parameters; string paramName = ""; foreach (OracleParameter OracleParameter in OracleParameterCollection) { if (OracleParameter.ParameterName == rowUniqueParmName) { paramName = RemoveParameterDelimiter(OracleParameter.ParameterName); result.RowUniqueIdCollection[paramName] = OracleParameter.Value; break; } } } else { if (getRowUniqueId) { string sQuery = "SELECT LAST_INSERT_ID()"; OracleCommand.CommandText = sQuery; OracleCommand.CommandType = CommandType.Text; result.RowUniqueId = OracleCommand.ExecuteScalar().ToString(); } } }
public ResultArgs GetDataBaseName(DataValue dv) { ResultArgs result = new ResultArgs(); SqlDataAdapter Adapter; SqlCommand Command = null; DataSet ds = new DataSet(); string connection = "server=" + dv.GetItem(0).FieldValue + ";port=" + dv.GetItem(1).FieldValue + ";uid=" + dv.GetItem(2).FieldValue + ";pwd=" + dv.GetItem(3).FieldValue + ";Allow User Variables=True;"; string sFetchQuery = "show databases"; DataTable dtFetchDb = new DataTable(); if (dv != null) { SqlConnection mcon = new SqlConnection(connection); mcon.Open(); Command = new SqlCommand(sFetchQuery, mcon); Adapter = new SqlDataAdapter(Command); if (result.dataSource == null) { result.dataSource = new DataTable(); } result.RowsAffected = Adapter.Fill(result.dataSource as DataTable); result.Success = true; } return(result); }
/// <summary>Execute Scalar Query </summary> /// <param name="dv">DataValue Object</param> /// <param name="query">The Select Query</param> /// <returns>If The Execute Scalar Returns the Null, the function will return /// the empty string otherwise the value</returns> /// <exception name="ArgumentNullException"></exception> /// <exception name="InvalidOperationException"></exception> public ResultArgs ExecuteScalar(DataValue dv, string query, EnumCommand.SQLType sqlType = EnumCommand.SQLType.Static) { ResultArgs resultArgs = new ResultArgs(); string ScalarValue = string.Empty; SqlCommand Command = null; SqlConnection Con = OpenConnection(); try { if (string.IsNullOrEmpty(query)) { // throw new ArgumentNullException("Query is empty!", "ExecuteScalar(DataValue dv, string query)"); using (ErrorLog objlog = new ErrorLog()) { objlog.WriteError("Error Handler", "ExecuteScalar(DataValue,string)", query, "Query is empty!"); } } if (dv == null) { Command = new SqlCommand(query, Con); } else { Command = SetSQLCommand(dv, query, Con, sqlType); } Object obj = Command.ExecuteScalar(); if (obj != null) { ScalarValue = obj.ToString(); resultArgs.Success = true; } } catch (InvalidOperationException ex) { using (ErrorLog objHandler = new ErrorLog()) { objHandler.WriteError("MysqlHandler", "ExecuteScalar(DataValue dv, string query)", ex.Message); objHandler.WriteError(ex); } } catch (Exception ex) { using (ErrorLog objHandler = new ErrorLog()) { objHandler.WriteError("MysqlHandler", "ExecuteScalar(DataValue dv, string query)", ex.Message); objHandler.WriteError(ex); } } finally { if (Command != null) { Command.Dispose(); } Command = null; CloseConnection(); } resultArgs.StringResult = ScalarValue; return(resultArgs); }
public ResultArgs CreateAppAuthenDongle(String userId, DongleUserInfo keyInfo) { ResultArgs ret = new ResultArgs(false); if (!IsActive()) { ret.Msg = "Create authen key failed -- no dongle opened!"; logger.Debug(ret.Msg); return(ret); } byte[] newAdminPin; byte[] appId; if (!Initialize(this.hDongle, userId, out newAdminPin, out appId)) { ret.Msg = "initialize dongle failed "; return(ret); } if (!CreateUserInfo(this.hDongle, keyInfo) || !CreateAuthenKeyFile(this.hDongle)) { ret.Msg = "Create Key info file failed !"; return(ret); } return(CreateAuthenKey(userId, appId, newAdminPin)); }
private void SetRowUniqueIdentifierValue(ResultArgs result, SqlCommand mySqlCommand) { if (mySqlCommand.CommandType == CommandType.StoredProcedure) { SqlParameterCollection mySqlParameterCollection = mySqlCommand.Parameters; string paramName = ""; foreach (SqlParameter mySqlParameter in mySqlParameterCollection) { if (mySqlParameter.ParameterName == rowUniqueParmName) { paramName = RemoveParameterDelimiter(mySqlParameter.ParameterName); result.RowUniqueIdCollection[paramName] = mySqlParameter.Value; break; } } } else { if (getRowUniqueId) { string sQuery = "SELECT @@identity"; mySqlCommand.CommandText = sQuery; mySqlCommand.CommandType = CommandType.Text; result.RowUniqueId = mySqlCommand.ExecuteScalar().ToString(); } } }
private ResultArgs CreateAuthenKey(String userId, byte[] appId, byte[] adminPin) { IntPtr pubKey = IntPtrUtil.Create(IntPtrUtil.SizeOf(typeof(RSA_PUBLIC_KEY))); IntPtr priKey = IntPtrUtil.Create(IntPtrUtil.SizeOf(typeof(RSA_PRIVATE_KEY))); ResultArgs ret = new ResultArgs(true); try { this.lastErrorCode = Dongle_RsaGenPubPriKey(this.hDongle, DongleConst.AUTHEN_KEY_DESCRIPTOR, pubKey, priKey); LogKey(pubKey, priKey); // renew appid this.dongleInfo[this.selectedIndex].AppId = this.Encoder.GetString(appId); RSA_PUBLIC_KEY pubStru = IntPtrUtil.ToStru <RSA_PUBLIC_KEY>(pubKey); ret.Result = new AppAuthenDongleResult() { PubKey = Convert.ToBase64String(pubStru.exponent, 0, DongleConst.RSA_KEY_LEN), Version = this.dongleInfo[this.selectedIndex].Version, AppId = this.dongleInfo[this.selectedIndex].AppId, UserId = userId, KeyPwd = this.Encoder.GetString(adminPin), KeyId = this.dongleInfo[this.selectedIndex].KeyId }; } finally { IntPtrUtil.Free(ref pubKey); IntPtrUtil.Free(ref priKey); // reset authen status as anonymous Reset(); } return(ret); }
private void TestKey(M1KeyMode keyMode, byte[] key) { ResultArgs ret = this.reader.Select(); if (!ret.Succ) { this.TraceMsg.Trace("Select Card Error!"); return; } CardSelectResult info = (CardSelectResult)ret.Result; this.TraceMsg.Trace(String.Format("Select card_id={0}, ATQA=0x{1}, SAK={2}", BitConverter.ToString(info.SN), info.ATQA.ToString("X4"), info.SAK.ToString("X2"))); foreach (CheckBox cb in this.cardSectorSelected) { if (!cb.Checked) { continue; } int sector = int.Parse(cb.Text.Trim()); if (!this.reader.Authen(keyMode, sector * 4, key)) { this.TraceMsg.Trace("Authen sector {0} failed !", sector); } else { this.TraceMsg.Trace("Authen sector {0} OK !", sector); } } }
/// <summary> /// /// </summary> /// <param name="sender"></param> /// <param name="e"></param> void _controller_ResultEvent(object sender, EventArgs e) { ResultArgs args = this._controller.ResultArgs; if (args.IsSuccess) { this.Sync.Post(new SendOrPostCallback(StatusBarTarget), args.Message); } else { this.Sync.Post(new SendOrPostCallback(MessageBoxTarget), args.Message); } if (args.IsSuccess) { if (args.IsComplete) { if (StringHelper.Equal(args.ExecuteArgs.ExecuteName, XD1100OperaNames.OPERA_READ)) { this.Sync.Post(new SendOrPostCallback(ReadLineTarget), args.KeyValues); this._canWrite = true; } else if (StringHelper.Equal(args.ExecuteArgs.ExecuteName, XD1100OperaNames.OPERA_WRITE)) { this.Sync.Post(new SendOrPostCallback(MessageBoxTarget), XD100Strings.WriteControlModeSuccess); } } } this._isExecuting = false; }
private void BtnCreateUserRootKey_Click(object sender, EventArgs e) { int selected = this.Dongles.SelectedIndex; byte[] userRootKey = HexString.FromHexString(this.UserRootKey.Text.Trim(), "-"); String userId = this.UserID.Text.Trim(); DongleUserInfo keyInfo = DongleUserInfo.CreateTestDongleKeyInfo(DongleType.USER_ROOT, userId); ResultArgs arg = this.dongle.CreateUserRootDongle(userId, userRootKey, keyInfo); if (arg.Succ) { this.TraceMsg.Trace(String.Format("Create user root key ok! "), true); UserRootDongleResult res = (UserRootDongleResult)arg.Result; this.TraceMsg.Trace(res.ToString()); logger.Debug(res.ToString()); } else { this.TraceMsg.Trace(String.Format("Create user root key Error! err msg = {0}", this.dongle.LastErrorMessage), true); } // refresh dongle RefreshDongle(false); }
public async Task <ResultArgs <object> > AskAdviceAsync(QuestionArgs questionArgs) { if (questionArgs == null) { throw new ArgumentNullException("questionArgs"); } //WE ONLY KNOW HOW TO DEAL WITH PHRASE EDIT QUESTIONS ABOUT PERCENT KNOWN. if (!(questionArgs.State is PhraseEdit) || questionArgs.Question != StudyResources.AdvisorQuestionWhatIsPhrasePercentKnown) { return(await new Task <ResultArgs <object> >(() => { var errorMsg = string.Format("Unknown question for advice.\n" + "questionArgs.State: {0}\n" + "questionArgs.Question: {1}", questionArgs.State.ToString(), questionArgs.Question); var error = new Study.StudyException(errorMsg); return new ResultArgs <object>(error); })); } var phrase = (PhraseEdit)questionArgs.State; var result = await GetPercentKnownAsync(phrase); //THE RESULT IS CASTED ALREADY AS A DOUBLE. WE NEED TO WRAP IT AS A DOUBLE var percentKnownObjectWrapper = new ResultArgs <object>(result.Object); return(await StudyHelper.WrapInTask <ResultArgs <object> >(percentKnownObjectWrapper)); //var answerTask = new Task<ResultArgs<object>>(() => { return new ResultArgs<object>(percentKnown); }); //return await answerTask; }
void LoadFinish(ref ResultArgs loadResultArgs) { GameObject ins = loadResultArgs.Instantiate(); ins.name = _index.ToString(); _index++; ins.transform.SetParent(Test, false); }
public IHttpActionResult Create(dynamic request) { String userId = Convert.ToString(request.userId); String jsonString = Convert.ToString(request.keyInfo); DongleUserInfo keyInfo = JsonConvert.DeserializeObject <DongleUserInfo>(jsonString); ResultArgs ret = DongleUtil.dongle.CreateAppAuthenDongle(userId, keyInfo); return(Json <ResultArgs>(ret)); }
public static ResultArgs Restore(String keyPwd) { byte[] keyPwdBytes = dongle.Encoder.GetBytes(keyPwd); ResultArgs ret = dongle.Restore(keyPwdBytes) ? new ResultArgs(true, null, "OK") : new ResultArgs(false, null, dongle.LastErrorMessage); return(ret); }
public ResultArgs Update(object command, Common.CommandType cmdType) { result = new ResultArgs(); try { objCommand = new SqlCommand(); objCommand.Connection = objConnection; if (hasTransaction) { objCommand.Transaction = objTransaction; } if (cmdType == Common.CommandType.StroeProcedure) { objCommand.CommandType = CommandType.StoredProcedure; QueryFetch objQueryFetch = new QueryFetch(); objCommand.CommandText = objQueryFetch.GetQuery(command); } else if (cmdType == Common.CommandType.Query) { objCommand.CommandType = CommandType.Text; QueryFetch objQueryFetch = new QueryFetch(); objCommand.CommandText = objQueryFetch.GetQuery(command); } BindParameterWithCommand(); if (objConnection.State != ConnectionState.Open) { objConnection.Open(); } result.AffectedRows = objCommand.ExecuteNonQuery(); result.Success = true; } catch (Exception ex) { Logger.WriteErrorLog(objCommand.CommandText); foreach (SqlParameter item in parameterCollection) { Logger.WriteErrorLog(string.Format("Name - {0} - Value - {1}", item.ParameterName, item.Value)); } Logger.WriteErrorLog(ex.Message); result.Message = ex.Message; result.AffectedRows = 0; result.Success = false; } finally { if (!hasTransaction) { objConnection.Close(); } parameterCollection.Clear(); } return(result); }
void LoadSceneEnd(ref ResultArgs args) { args.LoadScene(); var scene = SceneManager.GetActiveScene(); Debug.Log("scene = " + scene + " name " + scene.name); var allscenes = SceneManager.GetAllScenes(); Debug.Log("allscenes = " + allscenes.Length); }
public static async Task <ResultArgs <StudyItemViewModelArgs> > GetAbortedAsync() { var abortTask = new Task <ResultArgs <StudyItemViewModelArgs> >( () => { var abortResult = new ResultArgs <StudyItemViewModelArgs>(StudyItemViewModelArgs.Aborted); return(abortResult); }); return(await abortTask); }
public void CommitTrasaction(ResultArgs result) { if (result.Success) { objTransaction.Commit(); } else { objTransaction.Rollback(); } objConnection.Close(); }
public static ResultArgs FetchData <T>(OracleParameter[] param, string sSQL, EnumCommand.DataSource dataSourceType, string sAcademicYear = "") where T : new() { ResultArgs resultArgs = new ResultArgs(); DataValue dv = new DataValue(); dv.Clear(); try { if (string.IsNullOrEmpty(sSQL)) { resultArgs.Success = false; resultArgs.Message = Common.Message.QueryIsEmpty; return(resultArgs); } if (sAcademicYear != string.Empty) { sSQL = sSQL.Replace(Common.Delimiter.QUS + "", sAcademicYear); } //if (param != null) //{ // DataValue Construction // foreach (var prop in obj.GetType().GetProperties()) // { // objValue = prop.GetValue(obj, null); // objValue = (objValue == null) ? string.Empty : objValue.ToString(); // dv.Add(prop.Name, objValue.ToString(), EnumCommand.DataType.String); // } //} if (dataSourceType == EnumCommand.DataSource.list) { using (OracleHelper objHelper = new OracleHelper()) { resultArgs = objHelper.FecthDataAsList <T>(sSQL, param, EnumCommand.SQLType.StoredProcedure); } } else { using (OracleHelper objHelper = new OracleHelper()) { resultArgs = objHelper.FetchData(sSQL, dataSourceType, param, EnumCommand.SQLType.StoredProcedure); } } } catch (System.Exception ex) { using (ErrorLog objlog = new ErrorLog()) { objlog.WriteError("OracleHelper", "FetchData", sSQL, ex.Message); } resultArgs.Success = false; } return(resultArgs); }
public IHttpActionResult Encrypt(dynamic request) { String plain = Convert.ToString(request.plain); byte[] plainBytes = DongleUtil.dongle.Encoder.GetBytes(plain); byte[] cipher; ResultArgs ret = DongleUtil.dongle.Encrypt(DongleType.AUTHEN, plainBytes, out cipher) ? new ResultArgs(true, BitConverter.ToString(cipher), "OK") : new ResultArgs(false, null, DongleUtil.dongle.LastErrorMessage); return(Json <ResultArgs>(ret)); }
/// <summary> /// /// </summary> /// <param name="status"></param> private void Target(ResultArgs args) { //Console.WriteLine("RemoteController Target: {0} {1} {2} {3} ", // args.IsComplete, // args.IsSuccess, // args.Message, // args.ExecuteName); this._resultArgs = args; if (this.ResultEvent != null) { this.ResultEvent(this, EventArgs.Empty); } }
public IHttpActionResult Create(dynamic request) { String userId = Convert.ToString(request.userId); String rootKey = Convert.ToString(request.rootKey); byte[] rootKeyBytes = HexString.FromHexString(rootKey); String jsonString = Convert.ToString(request.keyInfo); DongleUserInfo keyInfo = JsonConvert.DeserializeObject <DongleUserInfo>(jsonString); ResultArgs ret = DongleUtil.dongle.CreateUserRootDongle(userId, rootKeyBytes, keyInfo); return(Json <ResultArgs>(ret)); }
/// <summary> /// select test 2 /// return card_id, atqa, sak /// </summary> private void BtnSelectCard2_Click(object sender, EventArgs e) { ResultArgs ret = this.reader.Select(); this.TraceMsg.Trace("Select Card " + ((ret.Succ) ? "OK!" : "Failed!"), true); if (ret.Succ) { CardSelectResult card = (CardSelectResult)ret.Result; this.TraceMsg.Trace(String.Format("card_id={0}, atqa=0x{1}, sak=0x{2}", BitConverter.ToString(card.SN), card.ATQA.ToString("X4"), card.SAK.ToString("X2"))); } }
public Object Parse(Type type, byte[] byteArray) { String func; if (type.Equals(typeof(Int16))) { func = "ToInt16"; } else if (type.Equals(typeof(UInt16))) { func = "ToUInt16"; } else if (type.Equals(typeof(Int32))) { func = "ToInt32"; } else if (type.Equals(typeof(UInt32))) { func = "ToUInt32"; } else if (type.Equals(typeof(UInt64))) { func = "ToUInt64"; } else if (type.Equals(typeof(Int64))) { func = "ToInt64"; } else { return(null); } IMethodBroker broker = new MethodBroker(typeof(BitConverter), func); ResultArgs ret = broker.Invoke(new List <Object> { byteArray }); if (ret.Succ) { return(ret.Result); } return(null); }
public byte[] GetBytes(object obj, int length) { IMethodBroker broker = new MethodBroker(typeof(BitConverter), "GetBytes"); Type type = numberType[obj.GetType().ToString()]; ResultArgs ret = broker.Invoke(new List <Object> { obj }); if (ret.Succ) { return(ret.Result as byte[]); } return(ByteUtil.Malloc(length)); }
/// <summary> /// Create user root dongle /// userRootKey can't less 16 bytes /// </summary> public ResultArgs CreateUserRootDongle(String userId, byte[] userRootKey, DongleUserInfo keyInfo) { ResultArgs ret = new ResultArgs(false); if (!IsActive()) { ret.Msg = "Create user root key failed -- no dongle opened!"; logger.Debug(ret.Msg); return(ret); } byte[] newAdminPin; byte[] appId; if (!Initialize(this.hDongle, userId, out newAdminPin, out appId)) { ret.Msg = "initialize dongle failed "; return(ret); } if (!CreateUserInfo(this.hDongle, keyInfo) || !CreateUserRootKeyFile(this.hDongle, DongleConst.USER_ROOT_KEY_DESCRIPTOR, userRootKey)) { ret.Msg = "Create User root Key failed !"; return(ret); } // renew appid this.dongleInfo[this.selectedIndex].AppId = this.Encoder.GetString(appId); // reset authen status as anonymous Reset(); ret.Succ = true; ret.Result = new UserRootDongleResult { KeyPwd = this.Encoder.GetString(newAdminPin), AppId = this.dongleInfo[this.selectedIndex].AppId, KeyId = this.dongleInfo[this.selectedIndex].KeyId, Version = this.dongleInfo[this.selectedIndex].Version, UserId = userId, TestCipher = CreateTestCipher(userId) }; return(ret); }
public ResultArgs Select() { ResultArgs ret = new ResultArgs(false); CardSelectResult cardInfo = new CardSelectResult(); if (this.hReader == -1) { return(ret); } //atqa :: M1_S50: 0x0004; M1_S70: 0x0002 UInt16 atqa = 0; if (dc_request(this.hReader, 0x00, ref atqa) != SUCC) { ret.Msg = "Can't request atqa !"; return(ret); } cardInfo.ATQA = atqa; byte[] sn = ByteUtil.Malloc(16); if (dc_anticoll(this.hReader, 0x00, sn) != SUCC) { ret.Msg = "AntiCollision Failed !"; return(ret); } // remove zero at the end cardInfo.SN = ByteUtil.TrimEnd(sn); //M1: sak = 0x08 //CPU simulate M1: sak=0x28 byte sak = 0x00; if (dc_select(this.hReader, sn, ref sak) != SUCC) { ret.Msg = "Can't get SAK!"; return(ret); } cardInfo.SAK = sak; ret.Succ = true; ret.Result = cardInfo; return(ret); }
/// <summary> /// /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void te_Ended(object sender, EventArgs e) { TaskExecutor exe = (TaskExecutor)sender; ExecuteEventArgs eeArgs = Get(exe); ResultArgs args = new ResultArgs(); args.ExecuteArgs = eeArgs.ExecuteArgs; args.IsComplete = true; args.IsSuccess = exe.Task.LastParseResult.IsSuccess; args.Message = exe.Task.LastParseResult.ToString(); if (args.IsSuccess) { args.KeyValues = exe.Task.LastParseResult.Results; } eeArgs.CallbackWrapper.Callback(args); }
public bool Initialize(UInt16[] sector) { ResultArgs ret = this.reader.Select(); if (!ret.Succ) { return(false); } CardSelectResult card = (CardSelectResult)ret.Result; this.logger.Debug(String.Format("card_id={0}, atqa=0x{1}, sak=0x{2}", BitConverter.ToString(card.SN), card.ATQA.ToString("X4"), card.SAK.ToString("X2"))); List <CardInitRequest> req = PrepareRequest(card.SN, sector); List <CardInitResponse> response = keyService.ComputeKey(req); return(UpdateCardKey(response)); }
void netfinder_OnAssignCompleted(object sender, ResultArgs e) { ShowMsg(e.Result); }