Data Verification

Introduction

Ensuring the accuracy of data is extremely important in managing data in sectors that are highly regulated and deal with sensitive information like property and identity management on the blockchain. By using a combination of automated and manual processes we can greatly improve the validation and accuracy of data. This comprehensive document will cover aspects of data verification with a specific focus on automating Know Your Customer (KYC) and Know Your Business (KYB) processes, as well as incorporating, off chain authority signatures.

Automated KYC & KYB

Automated Know Your Customer (KYC). Know Your Business (KYB) verification procedures have become fundamental components of contemporary data authentication systems. Utilizing services can simplify the process offering efficiency and dependability while also fulfilling crucial regulatory compliance obligations.

Know Your Customer (KYC)

Automated KYC involves verifying the identity of the customer using different mechanisms. Here are some prominent companies providing KYC services, and how they might be used in this project:

1. ShuftiPro: ShuftiPro offers real-time identity verification services. It uses OCR (Optical Character Recognition) to extract data from official documents, face verification to ensure the person is real and not using a mask or picture, and liveness detection to validate that the person is present during verification. It also uses AML (Anti-Money Laundering) screening against 1700+ watchlists and sanctions.

2. IDnow: IDnow provides AI-based KYC services. It uses machine learning to automate identity checks. It can validate various documents, including passports, using image recognition technology. IDnow can also perform video-based identity verification, adding an additional layer of security.

3. Idenfy: Idenfy offers identity verification services. It uses AI and biometrics, enabling businesses to verify the identities of their customers in real time. It can verify documents from more than 190 countries.

4. Udentify: Udentify's solution uses AI to analyze body language and facial expressions to determine whether a person is the owner of an ID. It can help reduce fraudulent activity.

5. ComplyCube: ComplyCube offers a robust KYC process, including identity verification, document verification, liveness check, and risk assessment. It uses AI to automate these checks, making the process fast and efficient.

6. IDwise: IDwise's KYC solution leverages AI to verify a person's identity, document legitimacy, and whether the person is physically present. It also offers watchlist checks and risk profiling.

Know Your Business (KYB)

On the side KYB aims to validate the legality and credibility of a business ensuring its adherence, to Anti Money Laundering (AML) and Counter Financing of Terrorism (CFT) regulations. This process entails confirming the businesss registration information comprehending its operations and identifying its Ultimate Beneficial Owners (UBOs). Many service providers also offer KYB services as part of their offerings.

Integration of KYC/KYB Services

Most of these services typically provide access to an API (Application Programming Interface). By integrating with these APIs you can automate the verification process. This involves making API calls with the required parameters such as user ID, document ID and image data. The responses, from the APIs including verification status and verified data can then be stored in a semi database. It is important to have error handling and retry mechanisms in place to handle any potential errors or downtimes of the APIs.

Authority Signatures and Entry Points

In addition to the automated KYC/KYB processes the system also incorporates a mechanism of off chain authority signatures and entry points. These authority signatures are manually verified off chain often provided by trusted companies known as entry points.

Entry points refer to companies that have already been verified and are authorized to operate within parameters. These companies possess the ability to verify data both off chain and, on chain. This dual verification process greatly enhances the trustworthiness and integrity of the data. The overall process can be summarized as follows;

1. Selection of Entry Points: Entry points are individually verified companies that can handle authority signatures. They are selected based on their reputation, reliability, and regulatory compliance.

2. Authority Signature: These entry points generate an authority signature for each piece of data they verify. This is a manual process where the entry points review the data and generate a signature if the data is correct.

3. On-chain Verification: Once the authority signature is generated, the data, along with the signature, is sent on-chain. An on-chain contract verifies the authority signature and, if valid, the data is stored on-chain.

4. Off-chain Verification: The authority signature can also be used for off-chain verification. When the data is required off-chain, the system can verify the authority signature to ensure the data's authenticity.

The integration of automated KYC/KYB procedures and off chain authority endorsements creates an reliable data verification system. It plays a role, in maintaining the integrity, dependability and precision of the data while effectively safeguarding against fraudulent activities.

Building User Interface for Manual Review and Verification

Although automated processes can handle a portion of the verification manual intervention is still crucial in the verification process. Incorporating a user interface can enhance the efficiency and effectiveness of the manual review process.

To build such an interface you have options, like Django (Python) or React (JavaScript) which are web development frameworks. These frameworks offer robustness and a diverse set of features enabling the creation of efficient and scalable applications.

The user interface should provide reviewers with the ability to;

• View the data to be verified along with all necessary details.

• Perform actions like approve, reject, or ask for re-verification based on the data.

• Leave comments or notes regarding their decision.

• Have a dashboard to view their progress and any metrics that might be important for their work.

The manual review process would generally follow these steps:

1. The reviewer logs in to the system with their secure credentials.

2. They are presented with a piece of data to verify.

3. They review the data and decide to approve, reject, or request additional verification.

4. The decision is saved in the system, and the data's status is updated accordingly.

It's crucial that this interface is secure because it will handle sensitive personal and business information. The application should follow best practices for handling data, ensuring that data is encrypted at rest and in transit, that access controls are in place, and that activity is logged for auditing.

Real Estate Data Verification

Ensuring the accuracy of real estate data is crucial in property transactions especially when utilizing blockchain technology. The verification process plays a role in confirming that all relevant information, about the property, including its condition, price and necessary approval documents is both precise and current. Once a contract has been established a reputable subsidiary takes charge of conducting checks approving the information and subsequently transmitting it to the blockchain.

Pre-Database to Verification

The pre-database is where the raw property data is initially stored. In this stage, the subsidiary will extract the necessary data for verification. Here is an example of a SQL query to fetch the data for verification:

SELECT property_id, property_condition, property_price, approval_document
FROM pre_database
WHERE property_id = '<target_property_id>';

Once the data is retrieved, the subsidiary will verify the data. The verification process can involve checking the approval document's validity, confirming the property's condition, and validating the price against the contract.

If the subsidiary verifies the data successfully, it will generate an approval signature. The approval signature is a cryptographic signature created using a private key only known to the subsidiary.

The signature can be created using C++ and a cryptographic library, such as OpenSSL. Below is a simplified example of how to generate a signature using OpenSSL:

#include <openssl/rsa.h>
#include <openssl/pem.h>
#include <openssl/err.h>
#include <openssl/sha.h>

// ...

// Load private key
FILE *fp = fopen("private.pem", "r");
RSA *rsa = PEM_read_RSAPrivateKey(fp, NULL, NULL, NULL);
fclose(fp);

// Hash the data
unsigned char hash[SHA256_DIGEST_LENGTH];
SHA256((unsigned char*)data.c_str(), data.size(), hash);

// Sign the data
unsigned char *sig = new unsigned char[RSA_size(rsa)];
unsigned int sigLen;
RSA_sign(NID_sha256, hash, sizeof(hash), sig, &sigLen, rsa);

// sig now contains the signature, and sigLen its length
// ...

Post-Verification

Once the data has been verified, it needs to be moved from the pre-database to the semi-database. Here is an example of a SQL transaction to do this:

BEGIN TRANSACTION;

-- Remove from pre-database
DELETE FROM pre_database
WHERE property_id = '<target_property_id>';

-- Insert into semi-database
INSERT INTO semi_database (property_id, property_condition, property_price, approval_document, approval_signature)
VALUES ('<target_property_id>', '<verified_property_condition>', '<verified_property_price>', '<verified_approval_document>', '<approval_signature>');

COMMIT;

On-chain Authfy Contract

The Authfy contract serves as a link between the off chain data stored in the connection database and the on chain data on the blockchain. Its main purpose is to obtain the signatures of entry points on the blockchain.

Designed for this purpose the Authfy contract receives the authority signature from a subsidiary. Verifies its validity. Once verified it transfers the data to the appropriate contract on the blockchain.

To accomplish this the Authfy contract receives both data and signature from the connection database. If it were possible to send an off chain signature snapshot to the blockchain there would be no need for an Authfy contract. However due to architectural limitations of most blockchains, including Ethereum, this direct snapshotting is not currently feasible.

Here is an example of how an Authfy contract could be implemented using Solidity, which's Ethereums primary language, for smart contracts.

pragma solidity >=0.7.0 <0.9.0;

contract Authfy {
    // ...
    function receiveDataAndSignature(bytes memory data, bytes memory signature) public {
        // Verify the signature
        bool isSignatureValid = verifySignature(data, signature);

        // If the signature is valid, transfer the data to the appropriate contract
        if (isSignatureValid) {
            // This is a simplified example. In practice, the data would need to be parsed and handled appropriately.
            targetContract.receiveData(data);
        }
    }
    // ...
}

In this simplified example the function called "receiveDataAndSignature" takes in both the data and the signature. It then checks if the signature is valid and if it is proceeds to send the data to the contract.

With that we come to the conclusion of the real estate data verification process. The whole procedure involves extracting data from a pre database verifying it off chain creating an authority signature and finally sending both the data and signature to an Authfy contract. This ensures that all information stored on the blockchain is accurate, dependable and can be verified.