Hyperledger INDY 지문정보 저장

대학교 링크사업으로 Hyperledger Indy의 DID에 생체 정보를 저장하는 프로젝트를 진행하였다.

결론적으로 기술적 한계로 인하여 DID에 저장하는 방식이 아닌 Verkey에 생체정보를 저장하게 되었다.

라즈베리파이에 지문인식 모듈과 웹캠을 연결하여 해당 생체 정보를 TCP 통신을 통해 INDY server에 전송하여 저장하는 방식이다.

지갑 생성관련 코드

indy server


import asyncio
import json
import pprint
import socket

from indy import pool, ledger, wallet, did, anoncreds
from indy.error import ErrorCode, IndyError

from utils import open_wallet, get_pool_genesis_txn_path, PROTOCOL_VERSION


pool_name = 'pool'
issuer_wallet_config = json.dumps({"id": "issuer_wallet"})
issuer_wallet_credentials = json.dumps({"key": "issuer_wallet_key"})
genesis_file_path = get_pool_genesis_txn_path(pool_name)


def print_log(value_color="", value_noncolor=""):
    """set the colors for text."""
    HEADER = '\033[92m'
    ENDC = '\033[0m'
    print(HEADER + value_color + ENDC + str(value_noncolor))


async def proof_negotiation(wallet_name,wallet_key,face,finger):
    try:
        await pool.set_protocol_version(PROTOCOL_VERSION)

        # 1.
        print_log('\n1. opening a new local pool ledger configuration that will be used '
                  'later when connecting to ledger.\n')
        pool_config = json.dumps({'genesis_txn': str(genesis_file_path)})
        try:
            await pool.create_pool_ledger_config(config_name=pool_name, config=pool_config)
        except IndyError as ex:
            if ex.error_code == ErrorCode.PoolLedgerConfigAlreadyExistsError:
                pass

        # 2.
        print_log('\n2. Open pool ledger and get the handle from libindy\n')
        pool_handle = await pool.open_pool_ledger(config_name=pool_name, config=None)

        # 3.
        print_log('\n3. Creating Issuer wallet and opening it to get the handle.\n')
        issuer_wallet_handle = await open_wallet(issuer_wallet_config, issuer_wallet_credentials)

        # 4.
        print_log('\n4. Generating and storing steward DID and verkey\n')
        steward_seed = '000000000000000000000000Steward1'
        did_json = json.dumps({'seed': steward_seed})
        steward_did, steward_verkey = await did.create_and_store_my_did(issuer_wallet_handle, did_json)
        print_log('Steward DID: ', steward_did)
        print_log('Steward Verkey: ', steward_verkey)

        # 5.
        print_log('\n5. Generating and storing trust anchor DID and verkey\n')
        trust_anchor_seed = '00000000000000000000000000Trust1'
        trust_anchor_did_json = json.dumps({'seed': trust_anchor_seed})
        trust_anchor_did, trust_anchor_verkey = await did.create_and_store_my_did(issuer_wallet_handle,
                                                                                  trust_anchor_did_json)
        print_log('Trust anchor DID: ', trust_anchor_did)
        print_log('Trust anchor Verkey: ', trust_anchor_verkey)

        # 6.
        print_log('\n6. Building NYM request to add Trust Anchor to the ledger\n')
        nym_transaction_request = await ledger.build_nym_request(submitter_did=steward_did,
                                                                 target_did=trust_anchor_did,
                                                                 ver_key=trust_anchor_verkey,
                                                                 alias=None,
                                                                 role='TRUST_ANCHOR')
        print_log('NYM transaction request: ')
        pprint.pprint(json.loads(nym_transaction_request))

        # 7.
        print_log('\n7. Sending NYM request to the ledger\n')
        nym_transaction_response = await ledger.sign_and_submit_request(pool_handle=pool_handle,
                                                                        wallet_handle=issuer_wallet_handle,
                                                                        submitter_did=steward_did,
                                                                        request_json=nym_transaction_request)
        print_log('NYM transaction response: ')
        pprint.pprint(json.loads(nym_transaction_response))

        # 8.
        print_log('\n8. Issuer create Credential Schema\n')
        schema = {
            'name': 'gvt',
            'version': '1.0',
            'attributes': '["age", "sex", "fingerprint", "name", "faceprint"]'
        }
        issuer_schema_id, issuer_schema_json = await anoncreds.issuer_create_schema(steward_did,
                                                                                    schema['name'],
                                                                                    schema['version'],
                                                                                    schema['attributes'])
        print_log('Schema: ')
        pprint.pprint(issuer_schema_json)

        # 9.
        print_log('\n9. Build the SCHEMA request to add new schema to the ledger\n')
        schema_request = await ledger.build_schema_request(steward_did, issuer_schema_json)
        print_log('Schema request: ')
        pprint.pprint(json.loads(schema_request))

        # 10.
        print_log('\n10. Sending the SCHEMA request to the ledger\n')
        schema_response = \
            await ledger.sign_and_submit_request(pool_handle,
                                                 issuer_wallet_handle,
                                                 steward_did,
                                                 schema_request)
        print_log('Schema response:')
        pprint.pprint(json.loads(schema_response))

        # 11.
        print_log(
            '\n11. Creating and storing Credential Definition using anoncreds as Trust Anchor, for the given Schema\n')
        cred_def_tag = 'TAG1'
        cred_def_type = 'CL'
        cred_def_config = json.dumps({"support_revocation": False})

        (cred_def_id, cred_def_json) = \
            await anoncreds.issuer_create_and_store_credential_def(issuer_wallet_handle,
                                                                   trust_anchor_did,
                                                                   issuer_schema_json,
                                                                   cred_def_tag,
                                                                   cred_def_type,
                                                                   cred_def_config)
        print_log('Credential definition: ')
        pprint.pprint(json.loads(cred_def_json))

        # 12.
        print_log('\n12. Creating Prover wallet and opening it to get the handle.\n')
        prover_did = 'VsKV7grR1BUE29mG2Fm2kX'
        prover_wallet_config = json.dumps({"id": wallet_name})
        prover_wallet_credentials = json.dumps({"key": wallet_key})
        prover_wallet_handle = await open_wallet(prover_wallet_config, prover_wallet_credentials)

        # 13.
        print_log('\n13. Prover is creating Link Secret\n')
        prover_link_secret_name = '12354'
        link_secret_id = await anoncreds.prover_create_master_secret(prover_wallet_handle,
                                                                     prover_link_secret_name)

        # 14.
        print_log('\n14. Issuer (Trust Anchor) is creating a Credential Offer for Prover\n')
        cred_offer_json = await anoncreds.issuer_create_credential_offer(issuer_wallet_handle,
                                                                         cred_def_id)
        print_log('Credential Offer: ')
        pprint.pprint(json.loads(cred_offer_json))

        # 15.
        print_log('\n15. Prover creates Credential Request for the given credential offer\n')
        (cred_req_json, cred_req_metadata_json) = \
            await anoncreds.prover_create_credential_req(prover_wallet_handle,
                                                         prover_did,
                                                         cred_offer_json,
                                                         cred_def_json,
                                                         prover_link_secret_name)
        print_log('Credential Request: ')
        pprint.pprint(json.loads(cred_req_json))

        # 16.
        print_log('\n16. Issuer (Trust Anchor) creates Credential for Credential Request\n')
        cred_values_json = json.dumps({
            "sex": {"raw": "male", "encoded": "5944657099558967239210949258394887428692050081607692519917050011144233"},
            "name": {"raw": "BONG", "encoded": "1139481716457488690172217916278103335"},
            "faceprint": {"raw": face, "encoded": "3213213123213213232"},
            "fingerprint": {
                "raw": finger,
                "encoded": "175"},
            "age": {"raw": "28", "encoded": "28"}
        })
        (cred_json, _, _) = \
            await anoncreds.issuer_create_credential(issuer_wallet_handle,
                                                     cred_offer_json,
                                                     cred_req_json,
                                                     cred_values_json, None, None)
        print_log('Credential: ')
        pprint.pprint(json.loads(cred_json))

        # 17.
        print_log('\n17. Prover processes and stores received Credential\n')
        await anoncreds.prover_store_credential(prover_wallet_handle, None,
                                                cred_req_metadata_json,
                                                cred_json,
                                                cred_def_json, None)

        print_log('\n17. 등록 끝 \n')

        print_log('\n22. Closing both wallet_handles and pool\n')
        await wallet.close_wallet(issuer_wallet_handle)
        await wallet.close_wallet(prover_wallet_handle)
        await pool.close_pool_ledger(pool_handle)

        # 23.
        print_log('\n23. Deleting created wallet_handles\n')
        # await wallet.delete_wallet(issuer_wallet_config, issuer_wallet_credentials)
        # await wallet.delete_wallet(prover_wallet_config, prover_wallet_credentials)

        # 24.
        print_log('\n24. Deleting pool ledger config\n')
        await pool.delete_pool_ledger_config(pool_name)


    except IndyError as e:
        print('Error occurred: %s' % e)


def main():

    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    server_socket.bind(('172.20.10.2', 8080))  # 주소 변경 (중요)
    server_socket.listen()
    print('INDY server start')
    client_soc, addr = server_socket.accept()
    data = client_soc.recv(4096)

    loop = asyncio.get_event_loop()

    if data is not None:
        wallet_name = data.decode().split('.')[0]
        wallet_key = data.decode().split('.')[1]
        face = data.decode().split('.')[2]
        finger= data.decode().split('.')[3]
        if finger.strip()[-1] == ',':
            finger = finger+'0]'
        elif finger.strip()[-1] == '0':
            finger = finger+']'

        loop.run_until_complete(proof_negotiation(wallet_name,wallet_key, face,finger))
    loop.close()


if __name__ == '__main__':
    main()

라즈베리파이


import socket
import cv2
import hashlib
import pymysql
from pyfingerprint.pyfingerprint import PyFingerprint

dir_path = "img"
dir = 0
cam_port = 0
cam = cv2.VideoCapture(cam_port)

def InsertWallet(wallet_name,wallet_key):
    con = pymysql.connect(host='localhost', user='root', password='1234', db='DID', charset='utf8')
    cur = con.cursor()
    sql = "insert into info(id,did,verkey) values (%s,%s,%s)"
    cur.execute(sql,(wallet_name,wallet_name,wallet_key))
    con.commit()
    con.close()

def face(imgname):
    enc = hashlib.md5(imgname.encode()).hexdigest()
    Ffile = "img/" + enc + ".png"
    print('C버튼을 눌러 사진을 찍어주세요')
    while True:
        ret, img = cam.read()
        if not ret:
            print("Can't read Camera")
            break
        cv2.imshow('Cam', img)
        if cv2.waitKey(1) == ord('c'):
            img_captured = cv2.imwrite(Ffile, img)
            cam.release()
            cv2.destroyAllWindows()
            break
    return enc

def fingerdata():
    try:
        f = PyFingerprint('/dev/ttyUSB0',57600, 0xFFFFFFFF, 0x00000000)
        if(f.verifyPassword() == False):
            raise ValueError('The given fingerprint sensor password is wrong!')

    except Exception as e:
        print('The fingerprint sensor could not be initialized!')
        print('Exception message:' + str(e))
        exit(1)
    try:
        print('Waiting for finger...') #지문 읽을때까지 기다림
        while(f.readImage() == False):
            pass
        #Converts read image to characteristics and stores it in charbuffer 1
        f.convertImage(0x01) #지문을 문자열 형태로 변환
        characterics = str(f.downloadCharacteristics(0x01)).encode('utf-8')

        return characterics.decode('utf-8')
    except Exception as e:
        print('Operation failed!')
        print('Exception message:' + str(e))
        exit(1)

socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

socket.connect(('172.20.10.2',8080))

print("wallet_name : ")
wallet_name = input()
print("wallet_key : ")
wallet_key = input()
InsertWallet(wallet_name,wallet_key)
finger = fingerdata()
face = face(wallet_name)


msg = wallet_name+'.'+wallet_key+'.'+face+'.'+finger

socket.sendall(msg.encode(encoding='utf-8'))

socket.close()

사용자 정보 전송(Indy → API server)

인디 서버 - 23.01.19

생체정보 조회 및 검증 관련 코드

인디서버


import asyncio
import json
import pprint
import socket

from indy import pool, ledger, wallet, did, anoncreds
from indy.error import ErrorCode, IndyError

from utils import open_wallet, get_pool_genesis_txn_path, PROTOCOL_VERSION
from signal import signal, SIGPIPE, SIG_DFL

signal(SIGPIPE,SIG_DFL)

global senddata

pool_name = 'pool'  # pool 이름
issuer_wallet_config = json.dumps({"id": "issuer_wallet"})  # issuer 지갑
issuer_wallet_credentials = json.dumps({"key": "issuer_wallet_key"})  # issuer 지갑 키값
genesis_file_path = get_pool_genesis_txn_path(pool_name)


def print_log(value_color="", value_noncolor=""):
    """set the colors for text."""
    HEADER = '\033[92m'
    ENDC = '\033[0m'
    print(HEADER + value_color + ENDC + str(value_noncolor))


async def proof_negotiation(walletname, key, method):
    try:
        await pool.set_protocol_version(PROTOCOL_VERSION)

        wallet_name = walletname  # 사용자 지갑 이름
        wallet_key = key  # 사용자 지갑 키값

        print(wallet_name)
        print(wallet_key)

        # 1. 인디 풀 생성
        print_log('\n1. opening a new local pool ledger configuration that will be used '
                  'later when connecting to ledger.\n')
        pool_config = json.dumps({'genesis_txn': str(genesis_file_path)})
        try:
            await pool.create_pool_ledger_config(config_name=pool_name, config=pool_config)
        except IndyError as ex:
            if ex.error_code == ErrorCode.PoolLedgerConfigAlreadyExistsError:
                pass

        # 2. 인디 풀 연결
        print_log('\n2. Open pool ledger and get the handle from libindy\n')
        pool_handle = await pool.open_pool_ledger(config_name=pool_name, config=None)

        # 3. Issuer(관리자) 지갑 생성
        print_log('\n3. Creating Issuer wallet and opening it to get the handle.\n')
        issuer_wallet_handle = await open_wallet(issuer_wallet_config, issuer_wallet_credentials)

        # 4. steward(관리자) DID 생성
        print_log('\n4. Generating and storing steward DID and verkey\n')
        steward_seed = '000000000000000000000000Steward1'
        did_json = json.dumps({'seed': steward_seed})
        steward_did, steward_verkey = await did.create_and_store_my_did(issuer_wallet_handle, did_json)
        print_log('Steward DID: ', steward_did)
        print_log('Steward Verkey: ', steward_verkey)

        # 5. trust anchor DID 생성
        print_log('\n5. Generating and storing trust anchor DID and verkey\n')
        trust_anchor_seed = '00000000000000000000000000Trust1'
        trust_anchor_did_json = json.dumps({'seed': trust_anchor_seed})
        trust_anchor_did, trust_anchor_verkey = await did.create_and_store_my_did(issuer_wallet_handle,
                                                                                  trust_anchor_did_json)
        print_log('Trust anchor DID: ', trust_anchor_did)
        print_log('Trust anchor Verkey: ', trust_anchor_verkey)

        # 6. 사용자 지갑 연결
        print_log('\n6. Creating Prover wallet and opening it to get the handle.\n')
        prover_did = 'VsKV7grR1BUE29mG2Fm2kX'
        prover_wallet_config = json.dumps({"id": wallet_name})
        prover_wallet_credentials = json.dumps({"key": wallet_key})
        prover_wallet_handle = await open_wallet(prover_wallet_config, prover_wallet_credentials)

        # 7. Issuer 스키마 생성
        print_log('\n7. Issuer create Credential Schema\n')
        schema = {
            'name': 'gvt',
            'version': '1.0',
            'attributes': '["age", "sex", "fingerprint", "faceprint","name"]'
        }
        issuer_schema_id, issuer_schema_json = await anoncreds.issuer_create_schema(steward_did,
                                                                                    schema['name'],
                                                                                    schema['version'],
                                                                                    schema['attributes'])
        print_log('Schema: ')
        pprint.pprint(issuer_schema_json)

        # 8. 사용자 지갑에 저장된 Credentail definition 출력
        print_log('\n8. Prover gets Credexals for Proof Request\n')
        proof_request = {
            'nonce': '123432421212',
            'name': 'proof_req_1',
            'version': '0.1',
            'requested_attributes': {
                'attr1_referent': {
                    'name': 'name',
                    "restrictions": {
                        "issuer_did": trust_anchor_did,
                        "schema_id": issuer_schema_id
                    }
                }
            },
            'requested_predicates': {
                'predicate1_referent': {
                    'name': 'age',
                    'p_type': '>=',
                    'p_value': 18,
                    "restrictions": {
                        "issuer_did": trust_anchor_did
                    }
                }
            }
        }
        print_log('Proof Request: ')
        pprint.pprint(proof_request)

        # 9. 사용자 지갑에 저장된 Credentail definition 출력
        print_log('\n9. Prover gets Credentials for attr1_referent anf predicate1_referent\n')
        proof_req_json = json.dumps(proof_request)
        prover_cred_search_handle = \
            await anoncreds.prover_search_credentials_for_proof_req(prover_wallet_handle, proof_req_json, None)

        creds_for_attr1 = await anoncreds.prover_fetch_credentials_for_proof_req(prover_cred_search_handle,
                                                                                 'attr1_referent', 1)
        prover_cred_for_attr1 = json.loads(creds_for_attr1)[0]['cred_info']
        print_log('Prover credential for attr1_referent: ')
        pprint.pprint(prover_cred_for_attr1)

        creds_for_predicate1 = await anoncreds.prover_fetch_credentials_for_proof_req(prover_cred_search_handle,
                                                                                      'predicate1_referent', 1)
        prover_cred_for_predicate1 = json.loads(creds_for_predicate1)[0]['cred_info']
        print_log('Prover credential for predicate1_referent: ')
        pprint.pprint(prover_cred_for_predicate1)

        credInfo = prover_cred_for_predicate1['attrs']

        global senddata

        if method == '2':
            senddata = credInfo['fingerprint']
        elif method == '1':
            senddata = credInfo['faceprint']

        await anoncreds.prover_close_credentials_search_for_proof_req(prover_cred_search_handle)

        # 10.
        print_log('\n10. Prover creates Proof for Proof Request\n')
        prover_requested_creds = json.dumps({
            'self_attested_attributes': {},
            'requested_attributes': {
                'attr1_referent': {
                    'cred_id': prover_cred_for_attr1['referent'],
                    'revealed': True
                }
            },
            'requested_predicates': {
                'predicate1_referent': {
                    'cred_id': prover_cred_for_predicate1['referent']
                }
            }
        })
        print_log('Requested Credentials for Proving: ')
        pprint.pprint(json.loads(prover_requested_creds))

        # 11. wallet, pool 종료
        print_log('\n11. Closing both wallet_handles and pool\n')
        await wallet.close_wallet(issuer_wallet_handle)
        await wallet.close_wallet(prover_wallet_handle)
        await pool.close_pool_ledger(pool_handle)

        # 12. wallet, pool 삭제
        # print_log('\n23. Deleting created wallet_handles and pool ledger config\n')
        # await wallet.delete_wallet(issuer_wallet_config, issuer_wallet_credentials)
        # await wallet.delete_wallet(prover_wallet_config, prover_wallet_credentials)
        await pool.delete_pool_ledger_config(pool_name)


    except IndyError as e:
        print('Error occurred: %s' % e)


def main():
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    server_socket.bind(('172.20.10.2', 8080)) #주소 변경 (중요)
    global senddata
    loop = asyncio.get_event_loop()

    while True:
        server_socket.listen()
        print('INDY server start')
        client_soc, addr = server_socket.accept()
        data = client_soc.recv(1024)
        if data is not None:

            wallet = data.decode().split('.')[0]
            key = data.decode().split('.')[1]
            method = data.decode().split('.')[2]


            loop.run_until_complete(proof_negotiation(wallet, key, method))


            client_soc.sendall(senddata.encode())

    server_socket.close()
    loop.close()

    print("Bye")


if __name__ == '__main__':
    main()

라즈베리파이


from deepface import DeepFace
from pyfingerprint.pyfingerprint import PyFingerprint
import pymysql
import cv2
import os
import hashlib
import socket


def sendinfo(wallet, key, method):s
    data = wallet + '.' + key + '.' + method

    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.connect(('192.168.0.135', 8080)) # 클라이언트의 연결요청을 기다리는 상태

    server_socket.sendall(data.encode())

    getdata = server_socket.recv(4096)

    return getdata


def fingermatch(data):
    try:
        f = PyFingerprint('/dev/ttyUSB0', 57600, 0xFFFFFFFF, 0x00000000)
        if (f.verifyPassword() == False):
            raise ValueError('The given fingerprint sensor password is wrong!')
    except Exception as e:
        print('The fingerprint sensor could not be initialized!')
        print('Exception message: ' + str(e))
        exit(1)
    try:
        print('Waiting for finger...')
        ## 지문이 읽힐때까지 기다림
        while (f.readImage() == False):
            pass
        ## Converts read image to characteristics and stores it in charbuffer 1
        s = f.convertImage(0x01)

        fingervalue = eval(data)

        f.uploadCharacteristics(0x02, fingervalue)

        score = f.compareCharacteristics()

        return score

    except Exception as e:
        print('Operation failed!')
        print('Exception message: ' + str(e))
        exit(1)


dir_path = "img"
dir = 0
cam_port = 0
cam = cv2.VideoCapture(cam_port)


def dir_chk():
    if os.path.isdir(dir_path):
        dir = 1
        print("Img Dir OK")
        return dir
    else:
        os.mkdir("img")
        print("Created Img Dir")
        if os.path.isdir(dir_path):
            dir = 1
            print("Img Dir OK")
            return dir


def livematch(imgname):
    dir_chk()
    enc = hashlib.md5()
    Ffile = "img/" + imgname + ".png"
    Sfile = "img/" + imgname + "1.png"
    print('plz press C')
    while True:
        ret, img = cam.read()
        if not ret:
            print("Can't read Camera")
            break
        cv2.imshow('Cam', img)
        if cv2.waitKey(1) == ord('c'):
            img_captured = cv2.imwrite(Sfile, img)
            cam.release()
            cv2.destroyAllWindows()
            break

    resp = DeepFace.verify(img1_path=Ffile, img2_path=Sfile, model_name='Facenet512')

    if os.path.isfile(Sfile):
        os.remove(Sfile)
        print('good')
    return resp['verified']


def getDID(id):
    con = pymysql.connect(host='localhost', user='root', password='1234', db='DID', charset='utf8')
    cur = con.cursor()
    sql = "select * from info where id = %s;"
    cur.execute(sql, id)
    DV = cur.fetchall()
    con.commit()
    con.close()
    return DV[0][1], DV[0][2]


def main():
    result = False
    print("input your ID")
    DV = getDID(input())
    wallet, key = DV[0], DV[1]
    print("================================")
    print("Wallet_name :", wallet)
    print("wallet_key:", key)
    print("================================")
    print("Select authentication method")
    print("1.Face 2.FingerPrint")
    finput = input()
    if finput == '1':
        print("input faceprint data")
        faceprint = sendinfo(wallet, key, finput).decode('utf-8' )
        result = livematch(faceprint)
    elif finput == '2':
        print("input fingerprint data")
        fingerdata = sendinfo(wallet, key, finput).decode('utf-8') + ']'
        if fingermatch(fingerdata) >= 60:
            result = True
        else:
            print("false")

    if result == 1:
        print("================================")
        print("success")
        print("================================")


if __name__ == '__main__':
    main()

(주의/ 카메라 연결 후 실행)

궁국적으로 추구하던 목적과는 많이 다른 결과물에 아쉽지만 블록체인 관련 지식을 얻을 수 있어 좋은 경험이었다고 생각한다.