<h2> 암호 해시 함수의 정의</h2> <p>메시지가 불법적으로 수정되지 않았음을 보장하는 것이며 메시지에 암호 해시 알고리즘을 사용한다 이 암호 해시 알고리즘은 메시지의 지문역할을 하며 원본과 동일함을 보장하는 중요한 역할을 할 것이다 지문이 포함된 메시지를 메시지 다이 제스트 라고 정의하겠다</p>

암호 해시 함수 조건

<ul> <li>단방향성이며 역함수는 존재하지 않는다</li> -> y=H(m) 일때 공격자가 m을 찾기 어려워야한다 역함수 찾는 것은 사실상 불가능 하게끔 만들어야한다 <li>약한 충돌 저항성</li> -> m과 H(m)이 주어진다 서로 다른 m과 m'이면서 동일한 해시함수인 H(m')=H(m)가 주어질때 m'을 찾기가 어려워야 한다. <li>강한 충돌 저항성</li> -> H(m')=H(m)안 서로 다른 메시지 m 과 m'을 찾기 어려워야한다 </ul>

SHA-n 알고리즘

python에서 hashlib을 사용하는 예

import hashlib
h = hashlib.sha256()
h.update(M.encode())
hash_data = h.hexdigest()

<hr>

전자 서명

전자서명은 문서 + 서명으로서 문서를 서명자가 작성했고 승인했음을 확인한다

메시지를 개인키로 암호화를 하고 수신 측에서 개인키로 암호화한 대상의 공개키로 복호가 되면 해당 문서에대한 전자서명이 검증 되는 것으로 신뢰성있는 메시지가 되는 것이다

타원 곡선 디지털 서명 구조

<ul> 키 생성 절차 <ol> <li>타원곡선을 선택한다 E(a,b)</li> <li>계산에 사용할 다른 소수 q를 선택한다</li> <li>개인키로 정수 d를 선택한다</li> <li>타원곡선위 한점 e1를 선택한다</li> <li>타원 곡선위 한점 e2를 계산한다 d * e1(...,...)</li> <li>공개키는 (a,b,p,q,e1,e2)이고 개인키는 d이다</li> </ol>

<hr> 서명절차 <ol> <li>임의의수 r을 선택한다</li> <li>곡선상의 한점 P(u,v)=r*e1(...,...)를 계산한다</li> <li>S1 = u mod q , S2 = SHA256(M) + d * S1 * r의 역원 mod q</li> <li>(S1 , S2)가 서명의 결과 이다</li>

</ol>

<hr> 검증 절차 <ol> <li>중간결과 A와 B를 계산한다</li> <li>A = h(M) * S2의역원 mod q , B = S1*S2의역원 mod q</li> <li>r = (h(m) + d * S1) * S2의 역원 mod q</li> <li>T(x,y) = A * e1(...,...) + B * e2(...,...) e2 = d * e1</li> <li>x mod q = S1 mod q 이면 검증이 완료된다</li>

</ol> </ul>

import hashlib
import os
import time
import random

from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives import hashes
p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
q = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
e1_x = 0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798
e1_y = 0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8

#역원 구하는 함수
def Extended_Uclidean(n, b):
  r1, r2 = n, b
  t1, t2 = 0, 1
  while r2:
      q = r1 // r2
      r = r1 - q * r2
      r1, r2 = r2, r
      t = t1 - q * t2
      t1 = t2
      t2 = t

  if r1 != 1:
      return 0
  if t1 < 0:
      t1 = n + t1
  return t1
def Add_Operation(P , Q , dp):
  if P == Q:
      slope = ((3 * (P[0]**2)) * Extended_Uclidean(dp , (2 * P[1])))%dp
  else:
      if Q[0] > P[0] :
          slope = ((Q[1] - P[1]) * Extended_Uclidean(dp , (Q[0] - P[0])))%dp
      else:
          slope = ((P[1] - Q[1]) * Extended_Uclidean(dp , (P[0] - Q[0])))%dp

  Tx = ((slope ** 2) - P[0] - Q[0])%dp
  Ty = (slope*(P[0]-Tx)-P[1])%dp
  return [Tx , Ty]

def Double_And_Add_Operation(Gx, Gy, key, dp):
  Binary_String = bin(key)
  Binary_String = Binary_String[3:len(Binary_String)]

  R_Gx = Gx
  R_Gy = Gy

  for currentBit in Binary_String:
      slope = ((3 * (R_Gx **2)) * (Extended_Uclidean(dp, 2 * R_Gy)))%dp
      PR_Gx = R_Gx
      R_Gx = ((slope **2) - PR_Gx - PR_Gx) % dp
      R_Gy = (slope * (PR_Gx - R_Gx) - R_Gy) % dp

      if currentBit == '1':
          if R_Gx >= Gx:
              slope = ((R_Gy-Gy) * (Extended_Uclidean(dp,R_Gx-Gx)))%dp
              R_Gx = ((slope**2) - Gx - R_Gx) % dp
              R_Gy = (slope * (Gx - R_Gx) - Gy) % dp
          else:
              PR_Gx = R_Gx
              slope = ((Gy-R_Gy) * (Extended_Uclidean(dp,Gx-R_Gx)))%dp
              R_Gx = ((slope**2) - R_Gx - Gx) % dp
              R_Gy = (slope * (PR_Gx - R_Gx) - R_Gy) % dp

  return [R_Gx , R_Gy]

def Sign(M,d) :
  r = random.randrange(1,q)
  P = Double_And_Add_Operation(e1_x , e1_y , r, p)
  S1 = P[0] % q
  h = hashlib.sha256()
  h.update(M.encode())
  hash_data = h.hexdigest()
  S2 = ((int(hash_data,16) + d * S1) * Extended_Uclidean(q,r)) % q
  print("1. Sign:")
  print("S1 = " + hex(S1))
  print("S2 = " + hex(S2))
  return [S1 , S2]

def Verify(M , S1 , S2 , e2):
  h = hashlib.sha256()
  h.update(M.encode())
  hash_data = h.hexdigest()
  A = (int(hash_data,16) * Extended_Uclidean(q,S2)) % q
  B = (S1 * Extended_Uclidean(q,S2)) % q

  T1 = Double_And_Add_Operation(e1_x,e1_y,A,p)
  T2 = Double_And_Add_Operation(e2[0],e2[1],B,p)

  answer = Add_Operation(T1 , T2 , p)

  print("A = " + hex(A))
  print("B = " + hex(B))

  if answer[0]%q == S1%q :
      return True
  else:
      return False

def random_key_generate():
  r = str(os.urandom(32)) + str(random.random()) + str(int(time.time() * 1000000))
  r = bytes(r, 'utf-8')
  h = hashlib.sha256(r).digest()
  key = ''.join('{:02x}'.format(y) for y in h)
  return key

while (1):
  private_key = random_key_generate()
  if int(private_key, 16) < p:
      break
#개인키
d = int(private_key,16)

Message = input("메시지? ")
P = Sign(Message , d)
print("2. 정확한 서명을 입력할 경우:")
e2 = Double_And_Add_Operation(e1_x , e1_y , d ,p)
if Verify(Message , P[0] , P[1] , e2) == True :
  print("검증 성공")
else :
  print("검증 실패")
print("3. 잘못된 서명을 입력할 경우:")
if Verify(Message, P[0]-1, P[1]-1, e2) == True:
  print("검증 성공")
else:
  print("검증 실패")