양자 후 암호화 구현 테스트: 개발자 가이드

# PQC 테스트를 위한 요구사항.txt pytest>=7.0.0 pytest-xdist>=3.0.0 # 병렬 테스트 실행 pytest-cov>=4.0.0 # 취재보고 가설>=6.0.0 # 속성 기반 테스트 liboqs-python>=0.9.0 # PQC 알고리즘 파이크립토돔>=3.19.0 # 추가 암호화 유틸리티

# conftest.py - Pytest 구성 수입 파이 테스트 수입 오크스 @pytest.fixture 데프 kyber_kem(): """Kyber-768 KEM 인스턴스를 제공하는 고정 장치""" 반품 oqs.KeyEncapsulation("카이버768") @pytest.fixture 데프 스핑크스_시그(): """SPHINCS+-SHAKE-128s 시그니처 인스턴스를 제공하는 고정 장치""" 반품 oqs.서명("SPHINCS+-SHAKE-128s-간단") @pytest.fixture 데프 kyber_keypair(kyber_kem): """테스트를 위해 사전 생성된 Kyber 키 쌍""" pk = kyber_kem.generate_keypair() sk = kyber_kem.export_secret_key() 반품 PK, SK @pytest.fixture 데프 스핑크스_키쌍(스핑크스_시그): """테스트를 위해 사전 생성된 SPHINCS+ 키 쌍""" pk = sphincs_sig.generate_keypair() sk = sphincs_sig.export_secret_key() 반품 PK, SK

# test_kats.py - 알려진 답변 테스트 수입 파이 테스트 수입 JSON ~에서 pathlib 수입 길 수업 테스트KyberKAT: """ NIST ML-KEM 사양의 Kyber-768 테스트 벡터에 대한 알려진 답변 테스트 """ @pytest.fixture 데프 kat_벡터(본인): """공식 KAT 벡터 로드""" kat_path = 경로(__file__).parent / "벡터" / "kyber768_kat.json" ~와 함께 열기(kat_path) as f: 반품 json.load(f) 데프 test_encapsulation_kat(자기, kat_벡터, kyber_kem): """캡슐화로 예상되는 암호문이 생성되는지 확인""" ~을 위한 벡터 in kat_벡터["캡슐화"]: pk = bytes.fromhex(벡터["공개_키"]) 예상_ct = bytes.fromhex(벡터["암호문"]) 예상_ss = bytes.fromhex(벡터["공유_비밀"]) 시드 = bytes.fromhex(벡터["씨앗"]) # 참고: 결정적 캡슐화에는 수정된 라이브러리가 필요합니다. # 참조 구현 패턴을 테스트합니다. ct, ss = kyber_kem.encap_secret(pk) # 암호문 길이 확인 주장하다 len(ct) == len(예상_ct), "암호문 길이 불일치" # 공유 ​​비밀 길이 확인 주장하다 len(ss) == len(예상_ss), "공유 비밀번호 길이 불일치" 데프 test_decapsulation_kat(자기, kat_벡터, kyber_kem): """캡슐 해제를 통해 예상 공유 비밀이 복구되는지 확인하세요.""" ~을 위한 벡터 in kat_벡터["캡슐화 해제"]: sk = bytes.fromhex(벡터["비밀_키"]) ct = bytes.fromhex(벡터["암호문"]) 예상_ss = bytes.fromhex(벡터["공유_비밀"]) kem = oqs.KeyEncapsulation("카이버768", sk) ss = kem.decap_secret(ct) 주장하다 ss == 예상_ss, "공유 비밀 불일치" 수업 테스트SPHINCSPlusKAT: """SPHINCS+-SHAKE-128s에 대한 알려진 답변 테스트""" @pytest.fixture 데프 kat_벡터(자체): kat_path = Path(__file__).parent / "벡터" / "sphincs128s_kat.json" ~와 함께 열기(kat_path) as f: 반품 json.load(f) 데프 test_signature_verification_kat(자기, kat_벡터): """알려진 서명이 올바르게 유효한지 확인하세요""" ~을 위한 벡터 in kat_벡터["확인"]: pk = bytes.fromhex(벡터["공개_키"]) 메시지 = bytes.fromhex(벡터["메시지"]) 서명 = bytes.fromhex(벡터["서명"]) 시그 = oqs.서명("SPHINCS+-SHAKE-128s-간단") is_valid = sig.verify(메시지, 서명, pk) 주장하다 is_valid, f"KAT 서명을 확인하지 못했습니다."

# test_roundtrip.py 수입 파이 테스트 수입 기미 수업 테스트KyberRoundTrip: """Kyber KEM에 대한 왕복 테스트""" 데프 test_basic_kem_cycle(자신, kyber_kem, kyber_keypair): """기본 캡슐화 → 캡슐화 해제 주기""" pk, sk = kyber_keypair # 캡슐화 암호문, shared_secret_enc = kyber_kem.encap_secret(pk) # 캡슐화 해제 kem_with_sk = oqs.KeyEncapsulation("카이버768", sk) shared_secret_dec = kem_with_sk.decap_secret(ciphertext) 주장하다 shared_secret_enc == shared_secret_dec @pytest.mark.parametrize("반복", [100, 1000]) 데프 test_repeated_kem_cycles(self, kyber_kem, kyber_keypair, 반복): """KEM이 여러 반복에 걸쳐 일관되게 작동하는지 확인하십시오.""" pk, sk = kyber_keypair kem_with_sk = oqs.KeyEncapsulation("카이버768", SK) ~을 위한 _ in 범위(반복): ct, ss_enc = kyber_kem.encap_secret(pk) ss_dec = kem_with_sk.decap_secret(ct) 주장하다 ss_enc == ss_dec 데프 test_다른_키쌍_생산_다른_결과(본인, kyber_kem): """다른 키가 다른 공유 비밀을 생성하는지 확인하세요.""" # 두 개의 서로 다른 키 쌍을 생성합니다 pk1 = kyber_kem.generate_keypair() sk1 = kyber_kem.export_secret_key() kem2 = oqs.KeyEncapsulation("카이버768") pk2 = kem2.generate_keypair() # 각각 캡슐화 ct1, ss1 = kyber_kem.encap_secret(pk1) ct2, ss2 = kyber_kem.encap_secret(pk2) # 공유 ​​비밀은 달라야 합니다 주장하다 ss1 != ss2 수업 테스트SPHINCSRoundTrip: """SPHINCS+ 서명에 대한 왕복 테스트""" 데프 test_basic_sign_verify(자기, sphincs_sig, sphincs_keypair): """기본 기호 → 확인주기""" pk, sk = sphincs_keypair 메시지 = b"SPHINCS+ 서명에 대한 테스트 메시지" # 징후 sig_with_sk = oqs.Signature("SPHINCS+-SHAKE-128s-간단", sk) 서명 = sig_with_sk.sign(message) # 확인하다 is_valid = sphincs_sig.verify(메시지, 서명, pk) 주장하다 is_valid @pytest.mark.parametrize("메시지_크기", [0, 1, 100, 1000, 10000, 100000]) 데프 test_various_message_sizes(자기, sphincs_sig, sphincs_keypair, message_size): """다양한 메시지 크기에 대해 서명이 작동하는지 확인하세요""" pk, sk = sphincs_keypair 메시지 = secrets.token_bytes(message_size) sig_with_sk = oqs.Signature("SPHINCS+-SHAKE-128s-간단", sk) 서명 = sig_with_sk.sign(message) 주장하다 sphincs_sig.verify(메시지, 서명, pk) 데프 테스트_서명_결정론(자기, sphincs_keypair): """ 참고: SPHINCS+는 기본적으로 무작위로 지정됩니다. 동일한 메시지가 다른 서명을 생성합니다(둘 다 유효함) """ pk, sk = sphincs_keypair 메시지 = b"테스트 메시지" sig1 = oqs.서명("SPHINCS+-SHAKE-128s-간단",sk) sig2 = oqs.Signature("SPHINCS+-SHAKE-128s-간단", sk) 서명1 = sig1.sign(메시지) 서명2 = sig2.sign(메시지) # 서명은 다르지만 둘 다 확인합니다. 주장하다 서명1 != 서명2 # 무작위로 검증자 = oqs.Signature("SPHINCS+-SHAKE-128s-간단") 주장하다 verifier.verify(메시지, 서명1, pk) 주장하다 verifier.verify(메시지, 서명2, pk)

# test_edge_cases.py 수입 파이 테스트 수업 테스트KyberEdgeCases: """Kyber의 극단적인 경우와 오류 조건""" 데프 test_invalid_public_key_length(본인, kyber_kem): """잘못된 공개 키 거부""" ~와 함께 pytest.raises(예외): kyber_kem.encap_secret(b"너무_짧다") 데프 test_invalid_ciphertext_length(자신, kyber_keypair): """잘못된 암호문 거부""" pk, sk = kyber_keypair kem = oqs.KeyEncapsulation("카이버768", SK) ~와 함께 pytest.raises(예외): kem.decap_secret(b"invalid_ciphertext") 데프 test_wrong_secret_key_fails_decap(자신, kyber_kem, kyber_keypair): """잘못된 키를 사용한 캡슐화 해제로 인해 다른 공유 비밀이 생성됩니다""" pk, sk = kyber_keypair # pk로 캡슐화 ct, ss_original = kyber_kem.encap_secret(pk) # 다른 키쌍 생성 kem2 = oqs.KeyEncapsulation("카이버768") kem2.generate_keypair() sk2 = kem2.export_secret_key() # 잘못된 키로 캡슐화 해제 kem_wrong = oqs.KeyEncapsulation("카이버768", sk2) ss_wrong = kem_wrong.decap_secret(ct) # 공유 ​​비밀은 달라야 합니다(IND-CCA 보안). 주장하다 ss_원본 != ss_잘못 수업 테스트SPHINCSEdgeCases: """SPHINCS+용 엣지 케이스""" 데프 test_empty_message(자기, sphincs_sig, sphincs_keypair): """빈 메시지에 서명하면 작동합니다""" pk, sk = sphincs_keypair 메시지 = b"" sig_with_sk = oqs.Signature("SPHINCS+-SHAKE-128s-간단", sk) 서명 = sig_with_sk.sign(message) 주장하다 sphincs_sig.verify(메시지, 서명, pk) 데프 test_modified_message_fails(자기, sphincs_sig, sphincs_keypair): """메시지가 수정되면 확인이 실패합니다.""" pk, sk = sphincs_keypair 메시지 = b"원본 메시지" sig_with_sk = oqs.Signature("SPHINCS+-SHAKE-128s-간단", sk) 서명 = sig_with_sk.sign(message) # 메시지 수정 수정됨 = b"수정된 메시지" 아니라고 주장하다 sphincs_sig.verify(수정, 서명, pk) 데프 테스트_수정_서명_실패(자기, sphincs_sig, sphincs_keypair): """서명이 수정된 경우 확인이 실패합니다.""" pk, sk = sphincs_keypair 메시지 = b"테스트 메시지" sig_with_sk = oqs.Signature("SPHINCS+-SHAKE-128s-간단", sk) 서명 = sig_with_sk.sign(message) # 서명을 약간 뒤집습니다. 수정된_시그 = 바이트어레이(서명) 수정된_시그[100] ^= 0x01 수정된_시그 = 바이트(수정_시그) 아니라고 주장하다 sphincs_sig.verify(메시지, 수정된_sig, pk) 데프 test_wrong_public_key_fails(자기, sphincs_sig, sphincs_keypair): """다른 공개 키를 사용하면 확인에 실패합니다.""" pk1, sk1 = sphincs_keypair # 두 번째 키쌍 생성 sig2 = oqs.서명("SPHINCS+-SHAKE-128s-간단") pk2 = sig2.generate_keypair() 메시지 = b"테스트 메시지" # sk1로 서명 sig_with_sk = oqs.Signature("SPHINCS+-SHAKE-128s-간단", sk1) 서명 = sig_with_sk.sign(message) # pk2로 확인하면 실패합니다 아니라고 주장하다 sphincs_sig.verify(메시지, 서명, pk2)

# test_properties.py ~에서 가설 수입 주어진, 전략 as st, 설정 수입 오크스 수업 테스트Kyber속성: """Kyber에 대한 속성 기반 테스트""" @주어진(st.binary(min_size=0, max_size=10000)) @설정(max_examples=100, 마감일=없음) 데프 test_encap_decap_roundtrip_any_key(자기, 무작위_데이터): """ 속성: 모든 키 쌍에 대해 encap 다음에 decap을 사용하면 항상 일치하는 공유 비밀이 생성됩니다. """ kem = oqs.KeyEncapsulation("카이버768") pk = kem.generate_keypair() sk = kem.export_secret_key() ct, ss_enc = kem.encap_secret(pk) kem_dec = oqs.KeyEncapsulation("카이버768",sk) ss_dec = kem_dec.decap_secret(ct) 주장하다 ss_enc == ss_dec @주어진(st.binary(min_size=1, max_size=1088)) @설정(max_examples=100, 마감일=없음) 데프 test_malformed_ciphertext_handled(자기, 쓰레기): """ 속성: 잘못된 암호문은 충돌하지 않으며 예외가 발생하거나 잘못된 암호를 반환합니다. """ kem = oqs.KeyEncapsulation("카이버768") kem.generate_keypair() sk = kem.export_secret_key() kem_dec = oqs.KeyEncapsulation("카이버768", SK) 노력하다: # 올리거나 반환해야 합니다(암시적 거부). 결과 = kem_dec.decap_secret(쓰레기) # 반환되면 괜찮습니다(암시적 거부). 주장하다 len(결과) == 32 # 여전히 32바이트 비밀값을 반환합니다. 제외하고 예외: # 키우는 것도 허용됩니다 통과하다 수업 테스트SPHINCS속성: """SPHINCS+에 대한 속성 기반 테스트""" @주어진(st.binary(min_size=0, max_size=50000)) @설정(max_examples=50, 마감일=없음) # 서명 속도가 느려서 적음 데프 test_sign_verify_any_message(본인, 메시지): """ 속성: 모든 메시지에 서명하고 확인할 수 있습니다. """ 서명 = oqs.서명("SPHINCS+-SHAKE-128s-간단") pk = sig.generate_keypair() sk = sig.export_secret_key() signer = oqs.Signature("SPHINCS+-SHAKE-128s-간단", sk) 서명 = signer.sign(message) 주장하다 sig.verify(메시지, 서명, pk) @주어진( st.binary(min_size=1, max_size=1000), st.integers(min_value=0, max_value=7855) ) @설정(max_examples=50, 마감일=없음) 데프 test_bit_flip_breaks_signature(자신, 메시지, 플립_위치): """ 속성: 서명의 비트를 뒤집으면 오류가 발생합니다. """ 서명 = oqs.서명("SPHINCS+-SHAKE-128s-간단") pk = sig.generate_keypair() sk = sig.export_secret_key() signer = oqs.Signature("SPHINCS+-SHAKE-128s-간단", sk) 서명 = signer.sign(message) # 위치에서 비트 뒤집기 수정됨 = bytearray(서명) byte_pos = 플립_위치 % len(수정됨) bit_pos = 플립_위치 % 8 수정됨[byte_pos] ^= (1 << bit_pos) modified = bytes(modified) # 검증에 실패해야 함 아니라고 주장하다 sig.verify(메시지, 수정됨, pk)

# test_synx_wallet.py 수입 파이 테스트 ~에서 synx_wallet 수입 SynXHDWallet, TransactionBuilder 수업 테스트SynXWallet통합: """SynX 양자 저항 지갑 통합 테스트""" @pytest.fixture 데프 테스트_지갑(본인): """알려진 니모닉으로 테스트 지갑 생성""" 니모닉 = "버리다 " * 23 + "미술" 반품 SynXHDWallet(니모닉, 암호="시험") 데프 test_address_derivation_deterministic(자체, test_wallet): """동일한 경로는 항상 동일한 주소를 생성합니다""" addr1 = test_wallet.derive_address(0, 0, 0) addr2 = test_wallet.derive_address(0, 0, 0) 주장하다 addr1.address == addr2.address 주장하다 addr1.kyber_public == addr2.kyber_public 주장하다 addr1.sphincs_public == addr2.sphincs_public 데프 test_다른_경로_다른_주소(자체, test_wallet): """다른 경로는 다른 주소를 생성합니다""" addr1 = test_wallet.derive_address(0, 0, 0) addr2 = test_wallet.derive_address(0, 0, 1) addr3 = test_wallet.derive_address(0, 1, 0) addr4 = test_wallet.derive_address(1, 0, 0) 주소 = {addr1.address, addr2.address, addr3.address, 주소4.주소} 주장하다 len(주소) == 4 데프 test_transaction_signing(자체, test_wallet): """서명된 거래가 올바르게 확인되었습니다""" 보낸 사람 = test_wallet.derive_address(0, 0, 0) 받는 사람 = test_wallet.derive_address(0, 0, 1) # 트랜잭션 구축 및 서명 builder = TransactionBuilder(test_wallet) tx = builder.add_output( receive.address, 100000000, receive.kyber_public ).build() # 서명 확인 서명 = oqs.서명("SPHINCS+-SHAKE-128s-간단") ~을 위한 입력 in tx.inputs: is_valid = sig.verify( tx.serialize_for_signing(), inp.sphincs_signature, inp.sphincs_public_key ) 주장하다 is_valid

# test_performance.py 수입 파이 테스트 수입 시간 수입 통계 수업 테스트성능벤치마크: """회귀 감지를 통한 성능 벤치마크""" # 예상 성능 기준(하드웨어별로 조정) KYBER_KEYGEN_MAX_MS = 10 KYBER_ENCAP_MAX_MS = 5 KYBER_DECAP_MAX_MS = 5 SPHINCS_KEYGEN_MAX_MS = 100 SPHINCS_SIGN_MAX_MS = 500 SPHINCS_VERIFY_MAX_MS = 50 데프 _기준(자체, 기능, 반복=100): """함수를 여러 번 실행하고 통계를 반환합니다.""" 횟수 = [] ~을 위한 _ in 범위(반복): 시작 = time.perf_counter() func() 경과 = (time.perf_counter() - 시작) * 1000 #ms 회.추가(경과) 반품 { "평균": 통계.평균(회), "중앙값": 통계.중앙값(회), "표준편차": 통계.stdev(회) if len(회) > 1 또 다른 0, "분": 분(회), "최대": 최대(회) } 데프 test_kyber_keygen_performance(본인): """예상 시간 내에 Kyber 키 생성""" 데프 키젠(): kem = oqs.KeyEncapsulation("카이버768") kem.generate_keypair() 통계 = self._benchmark(keygen) print(f"\nKyber 키 생성: {stats['mean']:.2f}ms (±{stats['stdev']:.2f})") 주장하다 통계["평균"] < self.KYBER_KEYGEN_MAX_MS 데프 test_sphincs_sign_performance(본인): """예상 시간 내에 SPHINCS+ 서명""" 서명 = oqs.서명("SPHINCS+-SHAKE-128s-간단") sig.generate_keypair() sk = sig.export_secret_key() 메시지 = b"x" * 256 데프 징후(): 서명자 = oqs.Signature("SPHINCS+-SHAKE-128s-간단", sk) signer.sign(message) stats = self._benchmark(sign, iterations=20) # 속도가 느려서 적음 인쇄(f"\nSPHINCS+ 기호: {stats['mean']:.2f}ms (±{stats['stdev']:.2f})") 주장하다 통계["평균"] < self.SPHINCS_SIGN_MAX_MS

# 모든 테스트를 커버리지로 실행 pytest 테스트/ -v --cov=synx_wallet --cov-report=html # KAT 테스트만 실행 pytest 테스트/test_kats.py -v # 병렬 실행으로 실행 pytest 테스트/ -n 자동 # 출력으로 성능 테스트 실행 pytest 테스트/test_performance.py -v -s