ブロックチェーンSNS概念設計：システム構築の品質評価のポイント9：効率性⑦

先までは、"愛記"についての記載で、どのようにブロックチェーンSNSに組み込んで実装していけばよいのか、概念的なところからアプローチ方法を記載していった。大まかな概念としてはひとまず終えた。次は、ブロックチェーンの概念設計といえるところまで、基本設計書に着手できるようなところまで、概念を具体化していきたい。

愛記システムのシステム評価について

システム評価とは、つまりは、このシステムを導入して成功だったか失敗だったかという効果検証という意味だ。概念設計をする上で必ず抑えておくべきポイントということだ。それには各項目があり、それぞれの項目を見ていくことで、その結果が得られる。そのシステム評価項目を1つずつ見ていきたい。

システム構築の品質評価のポイント1：理解可能性（Understandability）

システム構築の品質評価のポイント2：完全性（Completeness）

システム構築の品質評価のポイント3：簡潔性（Conciseness）

システム構築の品質評価のポイント4：移植性（Portability）

システム構築の品質評価のポイント5：一貫性（Consistency）と構造化の度合い

システム構築の品質評価のポイント6：保守性（Maintainability）

システム構築の品質評価のポイント7：試験性（Testability）

システム構築の品質評価のポイント8：ユーザビリティ（Usability）

システム構築の品質評価のポイント9：効率性（Efficiency）

システム構築の品質評価のポイント10：セキュリティ（Security）

システム構築の品質評価のポイント9：効率性⑦（Efficiency）

Proof of Place(PoP)のアルゴリズム

どうすれば、PoPのアルゴリズムで個人の匿名性を確保したアルゴリズムになるか。Proof of Place（PoP）のアルゴリズムで個人の匿名性を確保するためには、以下のような手段や考慮事項を組み込むことが重要であろう。これらの対策により、位置情報の利用やトランザクションの発生に伴うプライバシーのリスクを最小限に抑えることができる。

位置情報の匿名化:
- ユーザーの具体的な位置座標を保存せず、位置情報を十分なレベルで匿名化することが重要である。例えば、座標を大まかな地域やエリアにグループ化するなどの手法が考えられる。以下の例では、anonymize_locationメソッドを追加し、取得した緯度と経度を匿名化している。このメソッドでは、緯度と経度を小数点以下3桁まで丸めることで、位置情報を大まかな地域やエリアにグループ化している。これにより、ユーザーの具体的な位置座標を保存せず、プライバシーを保護することができる。
  import wifi # wifiモジュールのインストールが必要
  import geopy.distance
  
  def scan_wifi():
  # Wi-Fiネットワークのスキャンを実行し、アクセスポイントの情報を取得
  networks = wifi.scan()
  
  return networks
  
  def anonymize_location(latitude, longitude):
  # 座標を大まかな地域やエリアにグループ化する（例: 小数点以下3桁まで丸める）
  anonymized_latitude = round(latitude, 3)
  anonymized_longitude = round(longitude, 3)
  
  return anonymized_latitude, anonymized_longitude
  
  def calculate_distance(ap1, ap2):
  # 2つのアクセスポイントの座標を取得
  coordinates1 = (ap1["latitude"], ap1["longitude"])
  coordinates2 = (ap2["latitude"], ap2["longitude"])
  
  # 座標間の距離を計算
  distance = geopy.distance.geodesic(coordinates1, coordinates2).meters
  
  return distance
  
  def locate_position(ap_list):
  # アクセスポイント間の距離を計算してトライアングレーションを行い、位置を推定
  # この例では単純に3つのアクセスポイントの中間点を返す
  if len(ap_list) >= 3:
  ap1, ap2, ap3 = ap_list[:3]
  latitude = (ap1["latitude"] + ap2["latitude"] + ap3["latitude"]) / 3
  longitude = (ap1["longitude"] + ap2["longitude"] + ap3["longitude"]) / 3
  return latitude, longitude
  else:
  return None
  
  def main():
  # Wi-Fiスキャンを実行し、アクセスポイントの情報を取得
  access_points = scan_wifi()
  
  # アクセスポイントの情報を表示
  for ap in access_points:
  print(f"SSID: {ap['ssid']}, Signal Strength: {ap['signal']}, Latitude: {ap['latitude']}, Longitude: {ap['longitude']}")
  
  # 位置を推定
  estimated_position = locate_position(access_points)
  
  if estimated_position:
  # 位置情報を匿名化
  anonymized_position = anonymize_location(*estimated_position)
  print(f"Anonymized Position: {anonymized_position}")
  else:
  print("Position estimation failed.")
  
  if __name__ == "__main__":
  main()
ランダムなノイズの導入:
- 収集された位置情報にランダムなノイズを加えることで、正確な位置情報から個人を特定する難しさを増す。ただし、ノイズの導入は利便性とのトレードオフになるので、バランスを考慮する必要がある。
匿名トークンの使用:
- ユーザーに対して匿名なトークンを発行し、これを使用してトランザクションを行う仕組みを導入することで、個別のユーザーを特定しづらくなる。以下の例では、get_locationメソッドにユーザートークンを引数として追加した。このトークンはUUID（ユニークな識別子）を使用して生成され、各ユーザーに対して一意の識別子が割り当てられる。そして、このユーザートークンと位置情報が返されるようになる。これにより、位置情報とユーザーの関連付けが行われ、トランザクションの追跡が可能になるが、個別のユーザーを特定することが困難になる。
  import wifi # wifiモジュールのインストールが必要です
  import geopy.distance
  import random
  import uuid # UUIDモジュールのインポート
  
  class LocationManager:
  def __init__(self):
  self.geolocator = Nominatim(user_agent="my_app")
  
  def get_location(self, user_token):
  # モバイルデバイスのセンサーデータを取得
  sensor_data = self.get_sensor_data()
  
  # センサーデータを元に位置情報を補完
  latitude_sensor, longitude_sensor = self.interpolate_location(sensor_data)
  
  # モバイルネットワークプロバイダーから位置情報を取得
  latitude_network, longitude_network = self.get_network_location()
  
  # 補完された位置情報を統合
  latitude = (latitude_sensor + latitude_network) / 2
  longitude = (longitude_sensor + longitude_network) / 2
  
  # 位置情報にランダムなノイズを加える
  latitude += random.uniform(-0.005, 0.005) # 緯度にランダムなノイズを加える
  longitude += random.uniform(-0.005, 0.005) # 経度にランダムなノイズを加える
  
  # 緯度経度から住所を取得
  address = self.get_address(latitude, longitude)
  
  # ユーザートークンと位置情報を返す
  return user_token, latitude, longitude, address
  
  def get_sensor_data(self):
  # モバイルデバイスのセンサーデータを取得する処理を実装
  # この例では単純にダミーデータを返す
  return {"gyroscope": {"pitch": 0.1, "roll": 0.2, "yaw": 0.3}}
  
  def interpolate_location(self, sensor_data):
  # センサーデータから位置情報を補完する処理を実装
  # この例では単純にダミーデータを使用
  return 35.6895, 139.6917 # 仮の緯度経度
  
  def get_network_location(self):
  # モバイルネットワークプロバイダーから位置情報を取得する処理を実装
  # この例では単純にダミーデータを使用
  return 35.689, 139.692 # 仮の緯度経度
  
  def get_address(self, latitude, longitude):
  location = self.geolocator.reverse((latitude, longitude), language="ja")
  return location.address
  
  def main():
  location_manager = LocationManager()
  
  # ユーザートークンを生成
  user_token = str(uuid.uuid4())
  
  # 位置情報を取得
  user_token, latitude, longitude, address = location_manager.get_location(user_token)
  
  print(f"User Token: {user_token}")
  print(f"Latitude: {latitude}")
  print(f"Longitude: {longitude}")
  print(f"Address: {address}")
  
  if __name__ == "__main__":
  main()
セキュアな通信プロトコルの採用:
- 位置情報の取得やトランザクションの発生時には、セキュアで暗号化された通信プロトコルを使用することが必要である。これにより、第三者が情報を傍受するリスクを低減できる。以下の例では、secure_communication関数を追加し、SSLコンテキストを作成して、ソケットをセキュアにラップしている。その後、サーバーに接続し、セキュアな通信で位置情報を取得してブロックチェーンに追加している。なお、それをブロックチェーンのPoPアルゴリズムに組み込んでみると下記のようになるのだろう。
  from datetime import datetime
  from hashlib import sha256
  import wifi
  import geopy.distance
  import random
  import ssl
  import socket
  
  class Block:
  def __init__(self, index, previous_hash, timestamp, data, proof_of_place):
  self.index = index
  self.previous_hash = previous_hash
  self.timestamp = timestamp
  self.data = data
  self.proof_of_place = proof_of_place
  self.hash = self.calculate_hash()
  
  def calculate_hash(self):
  hash_data = (
  str(self.index) +
  str(self.previous_hash) +
  str(self.timestamp) +
  str(self.data) +
  str(self.proof_of_place)
  )
  return sha256(hash_data.encode()).hexdigest()
  
  class Blockchain:
  def __init__(self):
  self.chain = [self.create_genesis_block()]
  
  def create_genesis_block(self):
  return Block(0, "0", datetime.now(), "Genesis Block", "Proof of Place")
  
  def get_latest_block(self):
  return self.chain[-1]
  
  def add_block(self, data, proof_of_place):
  index = len(self.chain)
  previous_block = self.get_latest_block()
  new_block = Block(index, previous_block.hash, datetime.now(), data, proof_of_place)
  self.chain.append(new_block)
  
  def get_proof_of_place():
  # Wi-Fiアクセスポイントの情報を取得し、トライアングレーションによって位置情報を取得
  access_points = wifi.Cell.all('wlan0')
  # 仮の位置情報を返す
  latitude = random.uniform(35.6, 35.7)
  longitude = random.uniform(139.7, 139.8)
  return latitude, longitude
  
  def secure_communication():
  # SSLコンテキストの作成
  context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
  # サーバーに接続
  with socket.create_connection(('localhost', 12345)) as sock:
  with context.wrap_socket(sock, server_hostname='localhost') as ssock:
  # ブロックチェーンのインスタンスを作成
  my_blockchain = Blockchain()
  
  # ブロックを追加
  proof_of_place_1 = get_proof_of_place()
  my_blockchain.add_block("Transaction Data 1", proof_of_place_1)
  
  proof_of_place_2 = get_proof_of_place()
  my_blockchain.add_block("Transaction Data 2", proof_of_place_2)
  
  # ブロックチェーンを表示
  for block in my_blockchain.chain:
  print(f"Block #{block.index} - Hash: {block.hash}")
  
  def main():
  # セキュアな通信を行う
  secure_communication()
  
  if __name__ == "__main__":
  main()

これらの手段を組み合わせることで、PoPのアルゴリズムを構築し、ユーザーの位置情報を匿名で確保することが可能であろう。ただし、プライバシーに対する懸念を考慮した設計や法的な観点からの評価も欠かせない。

ただ、”愛貨”の場合、そこまで詳しい位置情報は不要である。ある市町村内にいるのか、いないのか、程度で良いのだ。居れば、その市町村ネットワークでトランザクションが処理されるというだけなのだから。そう考えると、上記のような位置情報の正確なモノが必要にならない。ある程度の範囲で良いのだ。よって、ユーザーの同意を毎回取得しなくても良い仕組みを考えたい。具体的な実装にはプロトコルの詳細な調整やセキュリティ検討が必要であろう。

円形エリア内の証明（Circular Area Proof）:
- ユーザーが特定の円形エリア内に存在することを示す。ユーザーはその円形エリアに対するゼロ知識証明を生成し、その情報をブロックチェーンに記録する。証明は円形エリアの半径と中心座標に関する情報を含み、具体的な座標情報は暗号化されている。他のユーザーはこれを検証することで、特定の円形エリア内に一定数以上のユーザーが存在することを確認できる。
多角形エリア内の証明（Polygon Area Proof）:
- ユーザーが特定の多角形エリア内に存在することを示す。ユーザーはその多角形エリアに対するゼロ知識証明を生成し、その情報をブロックチェーンに記録する。証明は多角形の頂点座標に関する情報を含み、具体的な座標情報は暗号化されている。他のユーザーはこれを検証することで、特定の多角形エリア内に一定数以上のユーザーが存在することを確認できる。
複数円形エリア内の証明（Multiple Circular Areas Proof）:
- ユーザーが複数の円形エリア内に存在することを示す。ユーザーは各円形エリアに対するゼロ知識証明を生成し、その情報をブロックチェーンに記録する。証明は各円形エリアの半径と中心座標に関する情報を含み、具体的な座標情報は暗号化されている。他のユーザーはこれを検証することで、特定の複数円形エリア内に一定数以上のユーザーが存在することを確認できる。

以下の例では、Blockクラスのproofs属性に複数の円形エリアの証明を格納し、Blockchainクラスのadd_blockメソッドでそれらの証明をブロックに追加している。そして、ブロックチェーンには複数の円形エリア内に存在することを示す情報が記録される。
from datetime import datetime
from hashlib import sha256
import wifi
import geopy.distance
import random
import ssl
import socket

class Block:
def __init__(self, index, previous_hash, timestamp, data, proofs):
self.index = index
self.previous_hash = previous_hash
self.timestamp = timestamp
self.data = data
self.proofs = proofs
self.hash = self.calculate_hash()

def calculate_hash(self):
hash_data = (
str(self.index) +
str(self.previous_hash) +
str(self.timestamp) +
str(self.data) +
str(self.proofs)
)
return sha256(hash_data.encode()).hexdigest()

class Blockchain:
def __init__(self):
self.chain = [self.create_genesis_block()]

def create_genesis_block(self):
return Block(0, "0", datetime.now(), "Genesis Block", ["Proof of Place A", "Proof of Place B"])

def get_latest_block(self):
return self.chain[-1]

def add_block(self, data, proofs):
index = len(self.chain)
previous_block = self.get_latest_block()
new_block = Block(index, previous_block.hash, datetime.now(), data, proofs)
self.chain.append(new_block)

def get_proof_of_place():
# Wi-Fiアクセスポイントの情報を取得し、トライアングレーションによって位置情報を取得
access_points = wifi.Cell.all('wlan0')
# 仮の位置情報を返す
latitude = random.uniform(35.6, 35.7)
longitude = random.uniform(139.7, 139.8)
return latitude, longitude

def generate_zero_knowledge_proof(area_info):
# 仮のゼロ知識証明を生成
encrypted_proof = f"Encrypted Proof for Area {area_info}"
return encrypted_proof

def secure_communication():
# SSLコンテキストの作成
context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
# サーバーに接続
with socket.create_connection(('localhost', 12345)) as sock:
with context.wrap_socket(sock, server_hostname='localhost') as ssock:
# ブロックチェーンのインスタンスを作成
my_blockchain = Blockchain()

# ブロックを追加
proof_of_place_A = get_proof_of_place()
proof_of_place_B = get_proof_of_place()
zero_knowledge_proof_A = generate_zero_knowledge_proof("Area A")
zero_knowledge_proof_B = generate_zero_knowledge_proof("Area B")
proofs = [zero_knowledge_proof_A, zero_knowledge_proof_B]
my_blockchain.add_block("Transaction Data", proofs)

# ブロックチェーンを表示
for block in my_blockchain.chain:
print(f"Block #{block.index} - Hash: {block.hash}")

def main():
# セキュアな通信を行う
secure_communication()

if __name__ == "__main__":
main()

このアルゴリズムでは、ユーザーが特定の位置に特定の時間帯に存在したことをゼロ知識証明とタイムスタンプを通じて確認する。これにより、位置情報と時間の組み合わせに基づく正当性の証明が行われることになる。

PoPとPoHを組み合わせたアルゴリズム

PoP（Proof of Place）とPoH（Proof of History）を組み合わせたアルゴリズムは、特定の位置に存在したことを証明するだけでなく、その履歴を確認することも可能となる。以下に、PoPとPoHを組み合わせたアルゴリズム案を示す。

時空間の連携証明（Temporal-Spatial Corroboration Proof）:
- ユーザーは特定の位置に存在することをPoPによって証明する。その後、その証明をPoHに組み込み、ユーザーが特定の時間において特定の位置に存在したことの歴史を不可逆に確認可能にする。これにより、ユーザーの存在証明が時空間にわたって連携される。
  from datetime import datetime
  from hashlib import sha256
  import wifi
  import geopy.distance
  import random
  import ssl
  import socket
  
  class Block:
  def __init__(self, index, previous_hash, timestamp, data, proof_of_place, proof_of_history):
  self.index = index
  self.previous_hash = previous_hash
  self.timestamp = timestamp
  self.data = data
  self.proof_of_place = proof_of_place
  self.proof_of_history = proof_of_history
  self.hash = self.calculate_hash()
  
  def calculate_hash(self):
  hash_data = (
  str(self.index) +
  str(self.previous_hash) +
  str(self.timestamp) +
  str(self.data) +
  str(self.proof_of_place) +
  str(self.proof_of_history)
  )
  return sha256(hash_data.encode()).hexdigest()
  
  class Blockchain:
  def __init__(self):
  self.chain = [self.create_genesis_block()]
  
  def create_genesis_block(self):
  return Block(0, "0", datetime.now(), "Genesis Block", "Proof of Place", "Proof of History")
  
  def get_latest_block(self):
  return self.chain[-1]
  
  def add_block(self, data, proof_of_place, proof_of_history):
  index = len(self.chain)
  previous_block = self.get_latest_block()
  new_block = Block(index, previous_block.hash, datetime.now(), data, proof_of_place, proof_of_history)
  self.chain.append(new_block)
  
  def get_proof_of_place():
  # Wi-Fiアクセスポイントの情報を取得し、トライアングレーションによって位置情報を取得
  access_points = wifi.Cell.all('wlan0')
  # 仮の位置情報を返す
  latitude = random.uniform(35.6, 35.7)
  longitude = random.uniform(139.7, 139.8)
  return latitude, longitude
  
  def get_proof_of_history():
  # ユーザーの行動履歴やログを元に、特定の時間における行動の証明を生成する
  # 仮の行動履歴証明を返す
  return "Proof of History"
  
  def secure_communication():
  # SSLコンテキストの作成
  context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
  # サーバーに接続
  with socket.create_connection(('localhost', 12345)) as sock:
  with context.wrap_socket(sock, server_hostname='localhost') as ssock:
  # ブロックチェーンのインスタンスを作成
  my_blockchain = Blockchain()
  
  # ブロックを追加
  proof_of_place_1 = get_proof_of_place()
  proof_of_history_1 = get_proof_of_history()
  my_blockchain.add_block("Transaction Data 1", proof_of_place_1, proof_of_history_1)
  
  proof_of_place_2 = get_proof_of_place()
  proof_of_history_2 = get_proof_of_history()
  my_blockchain.add_block("Transaction Data 2", proof_of_place_2, proof_of_history_2)
  
  # ブロックチェーンを表示
  for block in my_blockchain.chain:
  print(f"Block #{block.index} - Hash: {block.hash}")
  
  def main():
  # セキュアな通信を行う
  secure_communication()
  
  if __name__ == "__main__":
  main()
  
  このコードでは、Blockクラスにproof_of_history属性を追加し、それをブロックの計算に組み込んでいる。また、add_blockメソッドにproof_of_historyを受け取る引数を追加し、ブロックを生成する際に証明情報を渡すようにしている。

PoPにおける数学的アルゴリズム

Proof of Place（PoP）において、他の数学的アルゴリズムを組み合わせることで、新しいセキュリティやプライバシーの側面を強化できる。以下に、PoPに組み込む可能性のある数学的アルゴリズムの例を挙げてみよう。

Verifiable Delay Functions（VDF）:
- PoPにおいて、VDFを使用することで、特定の位置に存在したことを時間と共に証明する機能を強化できる。VDFは計算に時間がかかる性質を持っており、これを用いて位置情報の歴史を時間に基づいて確認することができる。
  from datetime import datetime
  from hashlib import sha256
  import wifi
  import geopy.distance
  import random
  import ssl
  import socket
  
  # VDFに必要な関数をシミュレート
  def simulate_vdf(input_data):
  # 単純なハッシュ計算を行い、計算に時間がかかるようにシミュレート
  result = sha256(input_data.encode()).hexdigest()
  for _ in range(1000000):
  result = sha256(result.encode()).hexdigest()
  return result
  
  class Block:
  def __init__(self, index, previous_hash, timestamp, data, proof_of_place, proof_of_history):
  self.index = index
  self.previous_hash = previous_hash
  self.timestamp = timestamp
  self.data = data
  self.proof_of_place = proof_of_place
  self.proof_of_history = proof_of_history
  self.hash = self.calculate_hash()
  
  def calculate_hash(self):
  hash_data = (
  str(self.index) +
  str(self.previous_hash) +
  str(self.timestamp) +
  str(self.data) +
  str(self.proof_of_place) +
  str(self.proof_of_history)
  )
  return sha256(hash_data.encode()).hexdigest()
  
  class Blockchain:
  def __init__(self):
  self.chain = [self.create_genesis_block()]
  
  def create_genesis_block(self):
  return Block(0, "0", datetime.now(), "Genesis Block", "Proof of Place", "Proof of History")
  
  def get_latest_block(self):
  return self.chain[-1]
  
  def add_block(self, data, proof_of_place, proof_of_history):
  index = len(self.chain)
  previous_block = self.get_latest_block()
  new_block = Block(index, previous_block.hash, datetime.now(), data, proof_of_place, proof_of_history)
  self.chain.append(new_block)
  
  def get_proof_of_place():
  # Wi-Fiアクセスポイントの情報を取得し、トライアングレーションによって位置情報を取得
  access_points = wifi.Cell.all('wlan0')
  # 仮の位置情報を返す
  latitude = random.uniform(35.6, 35.7)
  longitude = random.uniform(139.7, 139.8)
  return latitude, longitude
  
  def get_proof_of_history():
  # ユーザーの行動履歴やログを元に、特定の時間における行動の証明を生成する
  # ここではVDFを用いて計算に時間がかかるようにシミュレート
  input_data = "Proof of History"
  proof_of_history = simulate_vdf(input_data)
  return proof_of_history
  
  def secure_communication():
  # SSLコンテキストの作成
  context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
  # サーバーに接続
  with socket.create_connection(('localhost', 12345)) as sock:
  with context.wrap_socket(sock, server_hostname='localhost') as ssock:
  # ブロックチェーンのインスタンスを作成
  my_blockchain = Blockchain()
  
  # ブロックを追加
  proof_of_place_1 = get_proof_of_place()
  proof_of_history_1 = get_proof_of_history()
  my_blockchain.add_block("Transaction Data 1", proof_of_place_1, proof_of_history_1)
  
  proof_of_place_2 = get_proof_of_place()
  proof_of_history_2 = get_proof_of_history()
  my_blockchain.add_block("Transaction Data 2", proof_of_place_2, proof_of_history_2)
  
  # ブロックチェーンを表示
  for block in my_blockchain.chain:
  print(f"Block #{block.index} - Hash: {block.hash}")
  
  def main():
  # セキュアな通信を行う
  secure_communication()
  
  if __name__ == "__main__":
  main()
  
  このコードでは、get_proof_of_history関数内でVDFをシミュレートし、計算に時間がかかるようにしている。そして、ブロック生成時にこの計算済みのVDFの結果を proof_of_history としてブロックに組み込んでいる。

この数学的アルゴリズムは、PoPの目的や要件に応じて組み合わせることで、セキュリティやプライバシーの向上が期待できる。ただし、それぞれのアルゴリズムを組み合わせる際には、注意深い検討と詳細なプロトコル設計が必要である。

いかがであろうか、これがPoPの設計概要であった。とても簡単に記載しているが、実際はもっと複雑な仕組みとなる。一つずつ検証していきながら、チームで作り上げていく必要があるだろう。

続・ティール組織　研究会のブログ