public string SendCreateTransactionToDataBase <A, M>(AssetSaved <A> asset, MetaDataSaved <M> metaData, string privateSignKey)
        {
            var signPrivateKey = EncryptionService.getSignKeyFromPrivate(privateSignKey);

            var transaction = BigchainDbTransactionBuilder <AssetSaved <A>, MetaDataSaved <M> >
                              .init()
                              .addAssets(asset)
                              .addMetaData(metaData)
                              .operation(Operations.CREATE)
                              .buildAndSignOnly(signPrivateKey.PublicKey, signPrivateKey);

            var createTransaction = TransactionsApi <AssetSaved <A>, MetaDataSaved <M> > .sendTransactionAsync(transaction).GetAwaiter().GetResult();

            return(createTransaction.Data.Id);
        }
Example #2
0
        public IActionResult SignUp(mltSignUpViewModel mltSignUpViewModel)
        {
            string signPrivateKey = null, agreePrivateKey = null, signPublicKey = null, agreePublicKey = null;
            Assets <UserCredAssetData> userAsset = _bigChainDbService.GetUserAssetFromTypeID(AssetType.Doctor, mltSignUpViewModel.CSMLSID);

            if (userAsset != null)
            {
                ModelState.AddModelError("", "A Doctor profile with that MINC already exists");
                return(View(mltSignUpViewModel));
            }
            var passphrase = mltSignUpViewModel.MLTKeyWord;
            var password   = mltSignUpViewModel.Password;

            EncryptionService.getNewBlockchainUser(out signPrivateKey, out signPublicKey, out agreePrivateKey, out agreePublicKey);
            var userAssetData = new UserCredAssetData
            {
                FirstName       = mltSignUpViewModel.FirstName,
                LastName        = mltSignUpViewModel.LastName,
                ID              = mltSignUpViewModel.CSMLSID,
                Email           = mltSignUpViewModel.Email,
                PrivateKeys     = EncryptionService.encryptPrivateKeys(mltSignUpViewModel.CSMLSID, passphrase, signPrivateKey, agreePrivateKey),
                DateOfRecord    = DateTime.Now,
                SignPublicKey   = signPublicKey,
                AgreePublicKey  = agreePublicKey,
                FingerprintData = new List <string>(),
            };
            var userMetadata = new UserCredMetadata
            {
                hashedPassword = EncryptionService.hashPassword(password)
            };
            var asset = new AssetSaved <UserCredAssetData>
            {
                Type     = AssetType.MLT,
                Data     = userAssetData,
                RandomId = _random.Next(0, 100000)
            };
            var metadata = new MetaDataSaved <UserCredMetadata>
            {
                data = userMetadata
            };

            _bigChainDbService.SendCreateTransactionToDataBase(asset, metadata, signPrivateKey);
            return(RedirectToAction("Login"));
        }
Example #3
0
        public IActionResult UploadResult(UploadResultViewModel uploadResultViewModel)
        {
            // Get's the Doctor's information for current session
            ViewBag.DoctorName = HttpContext.Session.GetString(Globals.currentUserName);
            var oldViewModel = JsonConvert.DeserializeObject <UploadResultViewModel>(TempData["viewModel"] as string);

            uploadResultViewModel.TestData        = oldViewModel.TestData;
            uploadResultViewModel.PatientAsset    = oldViewModel.PatientAsset;
            uploadResultViewModel.PatientMetadata = oldViewModel.PatientMetadata;
            TempData["viewModel"] = JsonConvert.SerializeObject(uploadResultViewModel);

            if (!ModelState.IsValid)
            {
                return(View(uploadResultViewModel));
            }

            var doctorSignPrivateKey  = HttpContext.Session.GetString(Globals.currentDSPriK);
            var doctorAgreePrivateKey = HttpContext.Session.GetString(Globals.currentDAPriK);
            var doctorSignPublicKey   = EncryptionService.getSignPublicKeyStringFromPrivate(doctorSignPrivateKey);
            var patientSignPublicKey  = HttpContext.Session.GetString(Globals.currentPSPubK);

            var transID         = uploadResultViewModel.TestData.transID;
            var testRequisition = _bigChainDbService.GetMetaDataAndAssetFromTransactionId <string, double>(transID);

            //Check MLT has access to upload data
            if (testRequisition.metadata.AccessList.Keys.Contains(doctorSignPublicKey))
            {
                //Get hash key for requisition. We will use the same key for result
                var hashedKey         = testRequisition.metadata.AccessList[doctorSignPublicKey];
                var dataDecryptionKey = EncryptionService.getDecryptedEncryptionKey(hashedKey, doctorAgreePrivateKey);
                if (uploadResultViewModel.ResultFile != null)
                {
                    var    file             = uploadResultViewModel.ResultFile;
                    string base64FileString = "";

                    // Convert "file" into base64 string "base64FileString" to save into database
                    using (var ms = new MemoryStream())
                    {
                        file.CopyTo(ms);
                        var fileBytes = ms.ToArray();
                        base64FileString = Convert.ToBase64String(fileBytes);
                    }
                    //encrypt file data and save to ipfs
                    var encryptFileData = EncryptionService.getEncryptedAssetDataKey(base64FileString, dataDecryptionKey);
                    var cid             = _bigChainDbService.UploadTextToIPFS(encryptFileData);
                    var resultFile      = new FileData()
                    {
                        Data      = cid,
                        Type      = file.ContentType,
                        Extension = file.ContentType.Split('/').Last(),
                        Name      = file.FileName
                    };
                    //Encrypt the file using the same key
                    var encryptedFile = EncryptionService.getEncryptedAssetDataKey(JsonConvert.SerializeObject(resultFile), dataDecryptionKey);

                    var asset = new AssetSaved <TestResultAsset>
                    {
                        Data = new TestResultAsset
                        {
                            RequisitionAssetID = testRequisition.id,
                            EncryptedResult    = encryptedFile
                        },
                        RandomId = _random.Next(0, 100000),
                        Type     = AssetType.TestResult
                    };
                    //Access is managed by requisition asset
                    var metadata = new MetaDataSaved <double>();
                    metadata.AccessList = new Dictionary <string, string>();

                    _bigChainDbService.SendCreateTransferTransactionToDataBase(asset, metadata, doctorSignPrivateKey, patientSignPublicKey);
                    return(RedirectToAction("PatientRecords"));
                }
                else
                {
                    ModelState.AddModelError("", "Missing test result file.");
                    return(View(uploadResultViewModel));
                }
            }
            else
            {
                ModelState.AddModelError("", "You do not have permission to upload test result.");
                return(View(uploadResultViewModel));
            }
        }
Example #4
0
        public IActionResult AddNewPatientRecord(AddNewPatientRecordViewModel addNewPatientRecordViewModel)
        {
            ViewBag.DoctorName = HttpContext.Session.GetString(Globals.currentUserName);
            if (!string.IsNullOrEmpty(addNewPatientRecordViewModel.DoctorsNote.PurposeOfVisit))
            {
                var noteViewModel = addNewPatientRecordViewModel.DoctorsNote;
                var doctorNote    = new DoctorNote
                {
                    PurposeOfVisit      = noteViewModel.PurposeOfVisit,
                    Description         = noteViewModel.Description,
                    FinalDiagnosis      = noteViewModel.FinalDiagnosis,
                    FurtherInstructions = noteViewModel.FurtherInstructions,
                    DoctorName          = HttpContext.Session.GetString(Globals.currentUserName),
                    DoctorMinsc         = HttpContext.Session.GetString(Globals.currentUserID),
                    DateOfRecord        = DateTime.Now
                };
                string encryptionKey;
                var    encryptedData = EncryptionService.getEncryptedAssetData(JsonConvert.SerializeObject(doctorNote), out encryptionKey);

                var asset = new AssetSaved <string>
                {
                    Data     = encryptedData,
                    RandomId = _random.Next(0, 100000),
                    Type     = AssetType.DoctorNote
                };

                var metadata = new MetaDataSaved <double>();
                metadata.AccessList = new Dictionary <string, string>();

                //store the data encryption key in metadata encrypted with sender and reciever agree key
                var doctorSignPrivateKey  = HttpContext.Session.GetString(Globals.currentDSPriK);
                var doctorAgreePrivateKey = HttpContext.Session.GetString(Globals.currentDAPriK);
                var patientAgreePublicKey = HttpContext.Session.GetString(Globals.currentPAPubK);
                var patientSignPublicKey  = HttpContext.Session.GetString(Globals.currentPSPubK);
                var doctorSignPublicKey   = EncryptionService.getSignPublicKeyStringFromPrivate(doctorSignPrivateKey);
                var doctorAgreePublicKey  = EncryptionService.getAgreePublicKeyStringFromPrivate(doctorAgreePrivateKey);
                metadata.AccessList[doctorSignPublicKey] =
                    EncryptionService.getEncryptedEncryptionKey(encryptionKey, doctorAgreePrivateKey, doctorAgreePublicKey);
                metadata.AccessList[patientSignPublicKey] =
                    EncryptionService.getEncryptedEncryptionKey(encryptionKey, doctorAgreePrivateKey, patientAgreePublicKey);

                _bigChainDbService.SendCreateTransferTransactionToDataBase <string, double>(asset, metadata, doctorSignPrivateKey, patientSignPublicKey);
            }

            if (!string.IsNullOrEmpty(addNewPatientRecordViewModel.Prescription.DrugName))
            {
                var prescriptionViewModel = addNewPatientRecordViewModel.Prescription;
                var prescription          = new Prescription
                {
                    PrescribingDate = prescriptionViewModel.PrescribingDate,
                    Superscription  = prescriptionViewModel.Superscription,
                    DrugName        = prescriptionViewModel.DrugName,
                    Dosage          = prescriptionViewModel.Dosage,
                    //StartDate = prescriptionViewModel.StartDate,
                    EndDate         = prescriptionViewModel.EndDate,
                    Refill          = prescriptionViewModel.Refill,
                    Substitution    = prescriptionViewModel.Substitution,
                    DoctorName      = HttpContext.Session.GetString(Globals.currentUserName),
                    DoctorMinsc     = HttpContext.Session.GetString(Globals.currentUserID),
                    DirectionForUse = prescriptionViewModel.DirectionForUse
                };

                string encryptionKey;
                var    encryptedData = EncryptionService.getEncryptedAssetData(JsonConvert.SerializeObject(prescription), out encryptionKey);

                var asset = new AssetSaved <string>
                {
                    Data     = encryptedData,
                    RandomId = _random.Next(0, 100000),
                    Type     = AssetType.Prescription
                };

                var metadata = new MetaDataSaved <PrescriptionMetadata>
                {
                    AccessList = new Dictionary <string, string>(),
                    data       = new PrescriptionMetadata
                    {
                        RefillRemaining = prescription.Refill,
                        LastIssueQty    = -1
                    }
                };

                //store the data encryption key in metadata encrypted with sender and reciever agree key
                var doctorSignPrivateKey  = HttpContext.Session.GetString(Globals.currentDSPriK);
                var doctorAgreePrivateKey = HttpContext.Session.GetString(Globals.currentDAPriK);
                var patientAgreePublicKey = HttpContext.Session.GetString(Globals.currentPAPubK);
                var patientSignPublicKey  = HttpContext.Session.GetString(Globals.currentPSPubK);
                var doctorSignPublicKey   = EncryptionService.getSignPublicKeyStringFromPrivate(doctorSignPrivateKey);
                var doctorAgreePublicKey  = EncryptionService.getAgreePublicKeyStringFromPrivate(doctorAgreePrivateKey);
                metadata.AccessList[doctorSignPublicKey] =
                    EncryptionService.getEncryptedEncryptionKey(encryptionKey, doctorAgreePrivateKey, doctorAgreePublicKey);
                metadata.AccessList[patientSignPublicKey] =
                    EncryptionService.getEncryptedEncryptionKey(encryptionKey, doctorAgreePrivateKey, patientAgreePublicKey);

                _bigChainDbService.SendCreateTransferTransactionToDataBase <string, PrescriptionMetadata>(asset, metadata, doctorSignPrivateKey, patientSignPublicKey);
            }

            //There is a test result that exists
            if (!string.IsNullOrEmpty(addNewPatientRecordViewModel.TestRequisition.ReasonForTest))
            {
                //File exists
                if (addNewPatientRecordViewModel.TestRequisition.AttachedFile != null)
                {
                    var    file             = addNewPatientRecordViewModel.TestRequisition.AttachedFile;
                    string base64FileString = "";

                    // Convert "file" into base64 string "base64FileString" to save into database
                    using (var ms = new MemoryStream())
                    {
                        file.CopyTo(ms);
                        var fileBytes = ms.ToArray();
                        base64FileString = Convert.ToBase64String(fileBytes);
                    }
                    //encrypt file and store in ipfs
                    var encryptionKey = EncryptionService.getNewAESEncryptionKey();
                    var encryptedFile = EncryptionService.getEncryptedAssetDataKey(base64FileString, encryptionKey);
                    var id            = _bigChainDbService.UploadTextToIPFS(encryptedFile);

                    var testRequisition = new TestRequisitionAsset
                    {
                        AttachedFile = new FileData
                        {
                            Data      = id,
                            Type      = file.ContentType,
                            Extension = file.ContentType.Split('/').Last(),
                            Name      = file.FileName
                        },
                        ReasonForTest = addNewPatientRecordViewModel.TestRequisition.ReasonForTest,
                        TestType      = addNewPatientRecordViewModel.TestRequisition.TestType,
                        DateOrdered   = DateTime.Now
                    };
                    var encryptedData = EncryptionService.getEncryptedAssetDataKey(JsonConvert.SerializeObject(testRequisition), encryptionKey);

                    var asset = new AssetSaved <string>
                    {
                        Data     = encryptedData,
                        RandomId = _random.Next(0, 100000),
                        Type     = AssetType.TestRequisition
                    };

                    var metadata = new MetaDataSaved <double>();
                    metadata.AccessList = new Dictionary <string, string>();

                    //store the data encryption key in metadata encrypted with sender and reciever agree key
                    var doctorSignPrivateKey  = HttpContext.Session.GetString(Globals.currentDSPriK);
                    var doctorAgreePrivateKey = HttpContext.Session.GetString(Globals.currentDAPriK);
                    var patientAgreePublicKey = HttpContext.Session.GetString(Globals.currentPAPubK);
                    var patientSignPublicKey  = HttpContext.Session.GetString(Globals.currentPSPubK);
                    var doctorSignPublicKey   = EncryptionService.getSignPublicKeyStringFromPrivate(doctorSignPrivateKey);
                    var doctorAgreePublicKey  = EncryptionService.getAgreePublicKeyStringFromPrivate(doctorAgreePrivateKey);
                    metadata.AccessList[doctorSignPublicKey] =
                        EncryptionService.getEncryptedEncryptionKey(encryptionKey, doctorAgreePrivateKey, doctorAgreePublicKey);
                    metadata.AccessList[patientSignPublicKey] =
                        EncryptionService.getEncryptedEncryptionKey(encryptionKey, doctorAgreePrivateKey, patientAgreePublicKey);

                    _bigChainDbService.SendCreateTransferTransactionToDataBase <string, double>(asset, metadata, doctorSignPrivateKey, patientSignPublicKey);
                }
            }

            return(RedirectToAction("PatientOverview"));
        }
Example #5
0
        public IActionResult PatientSignUp(PatientSignUpViewModel patientSignUpViewModel)
        {
            // Description: Registers a patient up for a MedNet account
            ViewBag.DoctorName = HttpContext.Session.GetString(Globals.currentUserName);
            string signPrivateKey = null, agreePrivateKey = null, signPublicKey = null, agreePublicKey = null;
            Assets <PatientCredAssetData> userAsset = _bigChainDbService.GetPatientAssetFromID(patientSignUpViewModel.PHN);

            // Check if PHN is already in use
            if (userAsset != null)
            {
                ModelState.AddModelError("", "A Patient profile with that PHN already exists");
                return(View(patientSignUpViewModel));
            }

            // Register fingerprint information
            int           numScans = 5;
            List <Image>  fpList   = FingerprintService.authenticateFP("24.84.225.22", numScans);
            List <byte[]> fpdb     = new List <byte[]>();

            if (fpList.Count > numScans)
            {
                ModelState.AddModelError("", "Something went wrong with the fingerprint scan, try again.");
                return(View(patientSignUpViewModel));
            }

            // Parse the input data for user registration
            var passphrase = patientSignUpViewModel.KeyWord;
            var password   = patientSignUpViewModel.Password;

            // Encrypt fingerprint data
            List <string> encrList = new List <string>();

            foreach (var fp in fpList)
            {
                byte[] fpByte  = FingerprintService.imgToByte(fp);
                string encrStr = EncryptionService.encryptFingerprintData(patientSignUpViewModel.PHN, passphrase, fpByte);
                encrList.Add(encrStr);
            }

            // Create a user for the Blockchain
            EncryptionService.getNewBlockchainUser(out signPrivateKey, out signPublicKey, out agreePrivateKey, out agreePublicKey);

            // Create the user Asset
            var userAssetData = new PatientCredAssetData
            {
                ID              = patientSignUpViewModel.PHN,
                DateOfBirth     = patientSignUpViewModel.DateOfBirth,
                PrivateKeys     = EncryptionService.encryptPrivateKeys(patientSignUpViewModel.PHN, passphrase, signPrivateKey, agreePrivateKey),
                DateOfRecord    = DateTime.Now,
                SignPublicKey   = signPublicKey,
                AgreePublicKey  = agreePublicKey,
                FingerprintData = encrList,
            };

            // Encrypt the user's password in the metadata
            var userMetadata = new PatientCredMetadata
            {
                FirstName      = patientSignUpViewModel.FirstName,
                LastName       = patientSignUpViewModel.LastName,
                Email          = patientSignUpViewModel.Email,
                hashedPassword = EncryptionService.hashPassword(password)
            };

            // Save the user Asset and Metadata
            var asset = new AssetSaved <PatientCredAssetData>
            {
                Type     = AssetType.Patient,
                Data     = userAssetData,
                RandomId = _random.Next(0, 100000)
            };
            var metadata = new MetaDataSaved <PatientCredMetadata>
            {
                data = userMetadata
            };

            // Send the user's information to the Blockchain database
            _bigChainDbService.SendCreateTransactionToDataBase(asset, metadata, signPrivateKey);
            return(RedirectToAction("PatientLookUp"));
        }