Corona QR програмирование сертификата не проходящего проверку

[Zahlesel]

#! /usr/bin/env python3
import json
import sys
import zlib

import base45
import cbor2
from cose.messages import CoseMessage

data = 'HC1:6BFNX1:HM*I0PS3TLU.NGMU5AG8JKM:SF9VN1RFBIKJ:3 AXL1RR+ 8::N$OAG+RC4NKT1:P4.33GH40HD*98UIHJIDB 4N*2R7C*MCV+1AY3:YP*YVNUHC.G-NFPIR6UBRRQL9K5%L4.Q*4986NBHP95R*QFLNUDTQH-GYRN2FMGO73ZG6ZTJZC:$0$MTZUF2A81R9NEBTU2Y437XCI9DU 4S3N%JRP:HPE3$ 435QJ+UJVGYLJIMPI%2+YSUXHB42VE5M44%IJLX0SYI7BU+EGC SHG:AQ+58CEN RAXI:D53H8EA0+WAI9M8JC0D0S%8PO00DJAPE3 GZZB:X85Y8345MOLUZ3+HT0TRS76MW2O.0CGL EQ5AI.XM5 01LCWBA.RE.-SUYH+S7SBE0%B-KT+YSMFCLTQQQ6LEHG.P46UNL6DA2C$AF-SQ00A58HYO5:M8 7S$ULGC-IP49MZCSU8ST3HDRJNPV3UJADJ9BVV:7K13B4WQ+DCTEG4V8OT 09797FZMQ3/A7DU0.3D148IDZ%UDR9CYF'
payload = data[4:]
print("decoding payload: "+ payload)

# decode Base45 (remove HC1: prefix)
decoded = base45.b45decode(payload)

# decompress using zlib
decompressed = zlib.decompress(decoded)
# decode COSE message (no signature verification done)
cose = CoseMessage.decode(decompressed)
# decode the CBOR encoded payload and print as json
print(json.dumps(cbor2.loads(cose.payload), indent=2))

https://hackernoon.com/how-to-decode...ython-9v2c37s1

самый короткий код на декодирование демошифрования
скопировал куэр и послал через телеграм и в итоге оригинальные куер прочитались.
значит секрета никакого нет. ахуеть
ну как минимум для декодирования QR не нужен никакой ключ

[Zahlesel]

с закодированием данных пока косяк

#2 CBORBINARY
datacbor2 = cbor2.dumps(data_json)
print(datacbor2)
#3 COSE SIGNED
datacose = CoseMessage.encode(datacbor2)
print(datacose)
#4 ZLIBCOMPRESS

#5 BASE45 + HC1

на 3м шаге уже не знаю что делать, как закриптить

https://dgc.a-sit.at/ehn/generate

тут както делают, но слишком много шагов и в итоге сертификат не признается.
вопрос, почему для раскодировки не нужен никакой сертивикат?

# decode COSE message (no signature verification done)

 datacose = CoseMessage.encode(datacbor2)

TypeError: encode() missing 1 required positional argument: 'message'

https://pycose.readthedocs.io/en/lat...ncmessage.html

[Zahlesel]

так у нас выглядит COSE обьект с считываемого куэра
значит нужно закодировать таким способом: Sign1

<COSE_Sign1: [{'Algorithm': 'Es256'}, {'KID': b'^EVf\xa5\x1exW'}, b'\xa4\x01bDE' ... (280 B), b'\x95,<\x90\x0b' ... (64 B)]>

280byte payload

64byte signature

\cose,signature

b"\x95,<\x90\x0b,D\xe8&'\x0e\xbc\xc56Y\x9a\xc36\x8 5'\x13\xfe\x94H\xf3\xdb<\x13\xc1\xf5\xf3\xbd\x90sa b\xa0Cv?D\xb3\x93\x80\x89\xc2~\x99\xf92\xcf\x1a\xd 0\xb0&k\x95\xb9\xef\xf1'E@\xc1"

\cose,uhdr

{<class 'cose.headers.KID'>: b'^EVf\xa5\x1exW'}

\cose,phdr

{<class 'cose.headers.Algorithm'>: <class 'cose.algorithms.Es256'>}

\cose,key

None

прям ждем ответ. явно тип делет тоже, что и я
https://stackoverflow.com/questions/...signed-message

Enc0Message.encode
message = [self.phdr_encoded, self.uhdr_encoded, self.encrypt()]

AttributeError: 'dict' object has no attribute 'phdr_encoded'

тут пример с созданием обьекта
https://github.com/TimothyClaeys/pyc...ign1message.py

[Zahlesel]

https://hackernoon.com/covid-19-vacc...ption-6x3m3563
помоему я видел, что он свой джейсон закодировал в QR, теперь не могу найти эту информацию
https://harrisonsand.com/posts/covid-certificates/ вроде этот куек показывал.... засада

https://bastian.rieck.me/blog/posts/...n_certificate/

1. rq, for working with CBOR data.

может с этой библиотекой смогу зашифровать ЦБОР как положено


вот нашел скопированую у голландца инфу, которую он удалил гад

Python code:
headers = {
    'Authorization': '63e4f6bc-6705-c144-438f-97c0bbd9c2a5', // assets/appsettings.AppStore.json
    'User-Agent': 'FHICORC/38357 CFNetwork/1240.0.4 Darwin/20.5.0'
}

r = requests.get('https://koronakontroll.nhn.no/v2/publickey', headers=headers)
if r.status_code == 200:
    with open('certs.json', 'wb') as file:
        certs = r.content
        file.write(certs)

And you will get bunch of their official public keys.

Probably apps contains another API access data to get pem keys.

And generator on Python with TEST data (Python 3.7+, install base45==0.2.0, qrcode==6.1, Pillow==8.2.0, cbor2==5.4.0, cose==0.9.dev7, cryptography==3.4.7, unidecode==1.2.0 and others):

# Creates HC1 certificate for testing
# Certificate will not be valid as it will not be signed by official CA

# Definition of Data for Test Certificate
family_name = "Doe"
given_name = "John"
birthdate = "1911-11-11" # yyyy-mm-dd
country = "XX" # two letter country code
last_vaccination_date = "2021-05-01" # yyyy-mm-dd
cert_issuer = "Non Valid Test Certificate"
time_to_live = 180 * 24 * 3600 # validity period of cert, default 180 days
issuing_country = "XX" # two letter country code
keyid = bytes('01234567', 'utf-8') # first 8 hex values of SHA256 fingerprint of signing certificate, not relevant for test
# Private Signature Key for ecdsa-with-SHA256 for test certificate without password protection
# AS THIS IS JUST USED FOR PUBLIC TESTING IT IS NOT CRITICAL TO HAVE THIS PRIVATE KEY IN THIS CODE #
pem = b'-----BEGIN EC PRIVATE KEY-----\n' \
b'MHcCAQEEIICXhlDKAkd37q3LEtYmjoCuaIvne9/FzV0BClH2X52AoAoGCCqGSM49\n' \
b'AwEHoUQDQgAEL8eW9/mJUjRX0G6+dA2M9DHquAx5Q07wHFdZ0vM5WzkbOMNea2X2\n' \
b'iirLZ+RmhRAuDMZ6SN7Gj5uRrOo89+7KFA==' \
b'\n-----END EC PRIVATE KEY-----'
cert_id = "00XX/00000/1234567890/THISISATESTCERTIFICATEXXX#S"
vaccine_manufacturer = "ORG-100030215"
vaccine_id = "EU/1/20/1528"
dn = 2
sd = 2
tg = "840539006"
vp = "1119349007"
version = "1.0.0"

# Required imports
import unidecode
import json
from datetime import datetime
import cbor2
from cryptography.hazmat.primitives.serialization import load_pem_private_key
from cose.messages import Sign1Message
from cose.keys.curves import P256
from cose.algorithms import Es256
from cose.headers import Algorithm, KID
from cose.keys import CoseKey
from cose.keys.keyparam import KpAlg, EC2KpD, EC2KpCurve
from cose.keys.keyparam import KpKty
from cose.keys.keytype import KtyEC2
import zlib
from base45 import b45encode
import matplotlib.pyplot as plt
import qrcode

# Create upper case string without special characters and whitespace replaced by '<'
fnt = unidecode.unidecode(family_name).upper().replace(" ", "<")
gnt = unidecode.unidecode(given_name).upper().replace(" ", "<")

# Create json payload
json_issuance = '"v": [{"ci": "' + cert_id + '", "co": "' + country + '", "dn": ' + str(dn) + ', "dt": "' + \
last_vaccination_date + '", "is": "' + cert_issuer + '", "ma": "' + vaccine_manufacturer + \
'", "mp": "' + vaccine_id + '", "sd": ' + str(sd) + ', "tg": "' + tg + '", "vp": "' + vp + '"}]'
json_name = '"nam": {"fn": "' + family_name + '", "gn": "' + given_name + '", "fnt": "' + fnt + '", "gnt": "' + gnt + '"}'
json_payload = '{ ' + json_issuance + ', "dob": "' + birthdate + '", ' + json_name + ', "ver": "' + version + '"}'

# Make sure correct utf-8 was base
json_payload = json_payload.encode("utf-8")
json_payload = json.loads(json_payload.decode("utf-8"))

# Add additional required info to json_payload
json_payload = {
1: issuing_country,
4: int(datetime.now().timestamp() + time_to_live),
6: int(datetime.today().timestamp()),
-260: {
1: json_payload,
},
}
print("\nFULL JSON PAYLOAD:")
print(json_payload)

# Convert to CBOR
#
payload = cbor2.dumps(json_payload)
print("\nCBOR FORMAT:")
print(payload)

# Read in the private key that we use to actually sign this
#
keyfile = load_pem_private_key(pem, password=None)
priv = keyfile.private_numbers().private_value.to_bytes(3 2, byteorder="big")

# Prepare a message to sign; specifying algorithm and keyid
# that we (will) use
#
msg = Sign1Message(phdr={Algorithm: Es256, KID: keyid}, payload=payload)
print("\nMSG TO BE SIGNED:")
print(msg)

# Create the signing key - use ecdsa-with-SHA256
# and NIST P256 / secp256r1
#
cose_key = {
KpKty: KtyEC2,
KpAlg: Es256, # ecdsa-with-SHA256
EC2KpCurve: P256, # Ought to be pk.curve - but the two libs clash
EC2KpD: priv,
}

msg.key = CoseKey.from_dict(cose_key)
out = msg.encode()
print("\nSIGNED MESSAGE:")
print(out)

out = zlib.compress(out, 9)
print("\nCOMPRESSED MESSAGE:")
print(out)

out = b'HC1:' + b45encode(out)
print("\nBASE45 ENCODED:")
print(out)

qr = qrcode.QRCode(
version=1,
error_correction=qrcode.constants.ERROR_CORRECT_L,
box_size=10,
border=4,
)
qr.add_data(out)
qr.make(fit=True)
img = qr.make_image(back_color=(255, 255, 255), fill_color=(0, 0, 0))
imgplot = plt.imshow(img)
plt.show()

https://raidforums.com/Thread-TRADIN...zNAyWjcnBszQe9

[Zahlesel]

итак здесь онлайн генерирование QR
https://dgc.a-sit.at/ehn/

вшиты два сертификата

сверхуже используется один приватный и один sha

keyid = bytes('01234567', 'utf-8') # first 8 hex values of SHA256 fingerprint of signing certificate, not relevant for test

наврятли всё так просто, но его можно вычитать из объекта

keyid = bytes('^EVf\xa5\x1exW', 'utf-8')

потом при помощи ключа и кейайди генерируется подпись.
подпись я тоже могу вычитать

cose,signature

(b"\x95,<\x90\x0b,D\xe8&'\x0e\xbc\xc56Y\x9a\xc36\x 85'\x13\xfe\x94H\xf3\xdb<\x13"

b'\xc1\xf5\xf3\xbd\x90sab\xa0Cv?D\xb3\x93\x80\x89\ xc2~\x99\xf92\xcf\x1a'

b"\xd0\xb0&k\x95\xb9\xef\xf1'E@\xc1")

[Zahlesel]

код рабочий, нужно было пипом (pip) пару библиотек доинсталировать.
полученый куер не распознается, тк подписан неверно

вот что забавно, раскодируется крипт без проблем, в нем подпись для дешиврофки.
но она действительна только для того, что прописано внутри.
я думал ребята совсем тупые, ан нет

[Zahlesel]

https://dgc.a-sit.at/ehn/testsuite

на этой странице не понимап деяток кодировок и почему они используют столько много шагов

JSON
CBOR (Hex)
CWT (Hex) ??? это зачем? ответ ниже
COSE (Hex)

payload = cbor2.dumps(json_payload)

CBOR FORMAT:

b'\xa4\x01bXX\x04\x1ab\n\x0e\xc0\x06\x1aa\x1c\xc0\ xc09\x01\x03\xa1\x01\xa4av\x81\xaabcix100XX/00000/1234567890/THISISATESTCERTIFICATEXXX#SbcobXXbdn\x02bdtj2021-05-01bisx\x1bNon Valid Test CertificateXbmamORG-100030215bmplEU/1/20/1528bsd\x02btgi840539006bvpj1119349007cdobj1911-11-11cnam\xa4bfncDoebgndJohncfntcDOEcgntdJOHNcvere1.0 .0'

както не походит на хекс сверху

питон декодирует полученый куер с невалидным ключём, почему не материться?
не проверятся подпись?
а подпись должна валидироваться любым публичным ключём?

Verifying EU Digital COVID-19 Certificate with Python CWT
https://medium.com/@dajiaji/verifyin...t-fd3d5de27eed

The EC Private Key is necessary to generate a pass. However, it is not required for the verification process (only the Public Key is required). This seems to make any method using reverse engineering for Covid Pass applications on smartphones useless.

So, the only way to acquire an EC Private Key would be through hacking a machine used by a Certificate Signing Certificate Authority (CSCA) to generate passes.

смысл- без ключа с сервера дело табак


куча кода

eu-digital-green-certificates
https://github.com/eu-digital-green-certificates

[Zahlesel]

with open("key_aus_qrgenerator.crt", "rb") as file:
pem = file.read()
cert = x509.load_pem_x509_certificate(pem)
pub = cert.public_key().public_numbers()
key_x = pub.x.to_bytes(32, byteorder="big")
key_y = pub.y.to_bytes(32, byteorder="big")

fingerprint = cert.fingerprint(hashes.SHA256())
keyid = fingerprint[0:8].hex()

итак из сертификата можно получить keyid

из негоже можно получить KEY

cose.key = CoseKey.from_dict({KpKty: KtyEC2, EC2KpCurve: P256, KpAlg: Es256, EC2KpX: self.key_x, EC2KpY: self.key_y})

теперь не могу понять нах паблик кий?

keyfile = load_pem_private_key(pem, password=None)
priv = keyfile.private_numbers().private_value.to_bytes(3 2, byteorder="big")

cose_key = {
KpKty: KtyEC2,
KpAlg: Es256, # ecdsa-with-SHA256
EC2KpCurve: P256, # Ought to be pk.curve - but the two libs clash
EC2KpD: priv,
}

типо из сертификата можно получить ключ через EC2KpX
а из паблик ключа через EC2KpD ужоснах

EC 256 Key

\cose,signature

(b';\xa3\xd3vBkj\xbb\xd59`P\xf9.\xd1\xc7\xcd{\x84\ xc1\xdb\xd8\xb6\xbb'
b'\x90O\xcd\x1c\xdd\xed\xb0\x8d*EAt\xd1\xae>u\xe8\ xdd\xdc{E\x92\xcc\xb8d\xecI]'
b'.G \xdc\xf7\xf4\x94O,\xe1\xc6\xea')

RSA 2048 Key

\cose,signature

(b' w1D7D\x89\x03\xea\xec\xf9\xda\xbf.\\\xba\xbf2\x9b\ x9c\x8d\x1f\xf6\x96'
b"\xd9'6\x8c'\xf6\xc7e\xb5t5\xd9\xe2`\x91\x9c\x c1\ xe5\x9f\xedr\x90\xd2\xea"
b'\xbc\xd3\x9e\r5\x90\x02\xf6\xfa\xf9{\xde\xaa\x1d #<\xa8\n\xf9\xd6uK\xd9\xdd'
b'\xd6\x95\x17\xb0\xb0s\xc0G)\r\xa5\x10\xc5\xa2/f\xe4\x08\xddiP&\x99<'
b'~\xe2\x11Uo\x7f8L\xb9\xb3+\x1b\xf5\x05N\r\xebuW\ x17\xa8\xd4i\x1fq\x06\x877'
b'+Z\x91\x1c5]\x99a]J>KS\t\x8c\x92\xee\xda,\xad\x08\xbb\xa5\xe2j4\x18 \ x1c'
b"k\xf5\xe7\xa8H\x19\x0c\xa8_9=5\xa8\xd0&+\x85\ x95 \xf7f\xf5\x9c'\xa2"
b'>\xc0\x7f\xb93\xa5\x16\xccc\x06\x15[)\x97\xf4a\xfe\x88\xef^_\xab\xba\x1c'
b';\xa3OZ\xd5z9&2K\xc9\x97\xcf\t\xc7Z\xd1Q\xd8\x12 \x00"\xf0\xb8Xn\xa0\xfb'
b'\x02,\xb4\x8d\xddy\x99\xab\xde\xfc\x9a\x0c\x0c\x b3~\xaa\xd8:u3G\xee\xa5\x13'
b'\x1a\x1a\xea\xd1')

RSA 3072 Key

\cose,signature

(b"I\x86\xdfGxq\xce\x04\x0et '~i;9\xe7\x17\x14\xea\xc7r\xbfa\xcd\xd2\xc9\xd7"
b'\x97\xdaQ\xaa\x07\x970w5\x12\xeb\xcd\x96\x7f\xce[\xfd\x95D\x04'
b'\xd1\xb9\xb7\xfa\xc9 A\n\xdaq\xe7\xc0^\xb5N6U\x02\x9c7TT\xb6P#.\x1df'
b'\x9c68\xben\xbe\x89\x8cA-gY\xd8\x8e\xf0\x98z\x02:\xfa\xa3J\xf8\xe2'
b'\xd2\xbf\x0b\xe2\x88\xe6\x869\x1f\xf2M\xecr\xb2\ x1e\xc8z;\xa4\x9d'
b'!\x90\xed\x91\x92\xddm\x8d\xa27<(w\x8e\x8c\x8c\x c1\xcdt \x08\xdb#\x93'
b'\x8f\x0c\xfc4\x97Q1\xa5\xaf\xf5\xb3/\x0b\x05Gi!\xa8>\x81(\xb9\xf2\x19'
b'j\xab\xa8\xabF\x1f\xf9\xb0\x9ckY"C\xd3\x13P\xed\ xcd\x89\xa3\x0b\x8b\xa0\xea'
b'\xf6\xe1\x06:\x9e5X\xf3S\x8e\x83\xd5\xee\x10\x97 \x8c\xed\xce\xbc\xb8'
b'\x803\xff\x93\x0b\xb8_\x9a\x82X\x90^\xff\x8c-\x85\x17"\x1c\x99F\x9a\xf0\x94'
b'\x0f\xdf\xd8\xf5\x1a[\x1c\x12\x9e\xb6\xe6\xc6r\x07\xd1\xccJ\xa8\x1c\xcb '
b'\x12\x94\x0f\xe9\x9f)\xe6@\xcf\xb5\xd3C\xde\xae! \xc7\xf4\x90\x07\xd0'
b'\xf8\xe6a\x9c\x15w\xb0\xf3\xe2\xb1\xc55\x0f\xa0\ xf4<\xd3{\x922\xe0\x00\xb8!'
b'\xbbQw\x04Y\xc4@\xdc*\t\x13FF\xad5\xd49:\xf4^Z\x bcB\x0f\xdc\xf6l\xc5'
b':\x15\xd4,\xdc\xff\xb4\xcb\xf4]r\x89\xa1\xc9\x82/\xed\xd0O\x98\xf68&\xf4'
b'K\x8a\xd1\xf9\xea|L|L\x15h|\t\xdfb\x10q\x02\xd2W \xde\xff\xc3\x9a'
b'\xac\xa6\xdb\x19UI\xa9\xed')

Unprotected COSE (KID in unprotected header)

\cose,signature

(b']NB)\xaenU\r\x88\x947>#Y\x03\x8c\xbb\x8b\x86\x82(\x c4i\xd4`\x1b\xe4\x8c'
b'V\x91\xd8\xcc\xd8C\x16e\xb5\xde@\xd8cr\xff%\xec\ xcf,\xb4\xfe=\x1b\xb2ku\xbcb'
b'\x1f\x8d\xee\xe1 \x804\xf6')

декодер декодирует любое шифрование в 4ре строчки и без каких либо доп. ключей

[Zahlesel]

public_key = load_pem_hcert_dsc(dsc)
decoded = cwt.decode(eudcc, keys=[public_key])
так проверяется сертификат с COSE

"COSE": "d2844da20448d919375fc1e7b6b20126
"CERTIFICATE": "MIIBvTCCAWOgAwIBAgIKAXk8i8

https://github.com/eu-digital-green-...ode/raw/1.json


-----BEGIN EC PRIVATE KEY----- итак с приватключем мы работаем в скрипте который делает QR с картинкой

-----BEGIN PUBLIC KEY----- need the public key for the KeyID calculation
-----BEGIN CERTIFICATE-----

странный код с сервера тянется паблик и KID
тутже в коде написано, что паблик нужен для просчета KID
privat ключ и КИД нужны для подписи. зачем нужен сертификат? для проверки подлиности?

# Note - we only need the public key for the KeyID calculation - we're not actually using it.
#
with open(args.certfile, "rb") as file:
pem = file.read()
cert = x509.load_pem_x509_certificate(pem)
fingerprint = cert.fingerprint(hashes.SHA256())
keyid = fingerprint[0:8]

if args.set_keyid:
keyid = b64decode(args.set_keyid)

# Read in the private key that we use to actually sign this
#
with open(args.keyfile, "rb") as file:
pem = file.read()
keyfile = load_pem_private_key(pem, password=None)
priv = keyfile.private_numbers().private_value.to_bytes(3 2, byteorder="big")

# Prepare a message to sign; specifying algorithm and keyid
# that we (will) use
#
msg = Sign1Message(phdr={Algorithm: Es256, KID: keyid}, payload=payload)

# Create the signing key - use ecdsa-with-SHA256
# and NIST P256 / secp256r1
#
cose_key = {
KpKty: KtyEC2,
KpAlg: Es256, # ecdsa-with-SHA256
EC2KpCurve: P256, # Ought to be pk.curve - but the two libs clash
EC2KpD: priv,
}

# Encode the message (which includes signing)
#
msg.key = CoseKey.from_dict(cose_key)
out = msg.encode()
[URL="https://github.com/eu-digital-green-certificates/dgc-testdata/blob/main/AT/2DCode/raw/1.json"][/URL]

[Zahlesel]

КИД бывают из 8 знаков S2V5MlJF
, бывают кодированые Ll3NP03zOxY= занимают 12 символов
ощущение, что у нас в первом случае паблик кий

{"kid":"S2V5NVJF","publicKey":"MFkwEwYHKoZIzj0C AQY IKoZIzj0DAQcDQgAEOFOUp1+SLuaM3NnV+OMZKZOoPg76T7D+v qRCasD0BrRZmlUH2gD+aVlpKvp+u7h8ywTR7T6Z6/iI2Qe6F5begg=="},

а во втором сертификат, просто выдается и то и то в одном запросе

либо различная кодировка

{"kid":"JYwTuBN7gzg=","publicKey" :"MIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEAl l7v mpn6RCmx6ZA0vYNO3cOHlXO255SuFp3H3rYbV7IEcZjFD8z4r+ Uh8BCBNsqIBINkwcCRyp2HIupQbtT4txk1C88gcnr3UZmTOhCb QRCB8ePiV9QiAva3RE3v7ZVMlJM6dZt6uWjG41gOb4Znzw/ITt9X+h6Ljigc9fD41urF16iLGjMmbVZwnnu17GIpLZQ4kAJob Vf45QmKn3A1eYG/imrubrpVzjVnoklllyydJItTq3CMDhIkseITL1xid7C/1Qom1jDhGG2f3/yufbKoH32uSQ47XyA2lKDVHSi0YLl42YD/tQ66X7m1JkPaE21RaC+RIJpxp128XADZWe1xTEPPm9usIjCyrv LOL6Gjcfbm78Qx1Slb8D1sUEufKjXAoZ3Qbhs6GC6i3jCy8Q/Ef
pMtsqd7vfMHs9ZkWV4C6YNmQ1/eSrPHUclxzSAsVNcFEq/iKuRWmmb5Y3Xdrb3hm5YWO+RMDYakbmPlvjUJjxoJAzPHu4tG0 QG9e+TFAgMBAAE="}]

MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQc ужевстречался как пабликкий

а MIIBvTCCAWOgAwIBAgIKAXk8i88OleLsuTAKBggqhkjO был сертификате с CWT проверкой
# A DSC(Document Signing Certificate) issued by a CSCA (Certificate Signing Certificate Authority)
если поставить вместо него в скрипт python_cwt_sample_eudcc_01.py значение с сервака, то сертификат не обнаруживается

МХа же как приваткий в скрипте с куэр из кия и кийайди

[Zahlesel]

/CovPass_v1.28.7_apkpure.com/assets/covpass-sdk/dsc-list.json

здесь есть два сертигфиката

{"certificates":[{"certificateType": "DSC", "country": "DE", "kid": "L7XIA2gi2ps=", "rawData": "MIIHUTCCBQmgAwIBAgIQUl/....
.....
I3jIOuyvySylMuE=", "signature": "bm8gc2lnbmF0dXJlIHNvIGZhcg==", "thumbprint": "2FB5C8036822DA9B57C5A8727F2396B441E36CC94B378223FD710CF948F967B6", "timestamp": "2021-05-18T10:36:56+02:00"}

подставив его в python_cwt_sample_eudcc_01.py cwt.decode не прокатило

тамже лежит один сертификат backend-ca.pem
и один паблик кий dsc-list-signing-key.pem

[Zahlesel]

https://harrisonsand.com/posts/covid-certificates/
запилил код, сделав его рабочим смог убедится. что первый код с рабочим сертификатом годный
второй же джон доу сгенерированый на сайте не проходит сертификацию
ключик ищется в джейсоне

import json
import base64
from cryptography.hazmat.primitives.serialization import load_der_public_key
import base45
import zlib
import cbor2
from cose.messages import CoseMessage
from cose.headers import Algorithm, KID
from cose.keys import EC2Key, CoseKey


#ORIGINAL FULL VACTINATED
data = 'HC1:6BFOXN*TS0BI$ZDFRH%YJLABRKAIPH7699FH3XHP+56R5 UC9I05O/CAH9BVIP*D/GPWBILC9GGBYPLR-S E10EQ928GEQW2DVJ5UL8W2BV:88J4TM8TOE.N8NI2$4AF44CNC 4DRI45IN2Y01%PCSN8R3D5%C2%K:XFMFG.A5:S9395*CBVZ0K1 HI 0CNNZ 2ZJJ.V47NV/HLWU4L8S1JPTQNXHF+X47Y45W4MKN4NN3F85QNCY0O%0$88:0L PHN6D7LLK*2HG%89UV-0LZ 2S-O:S9UZ4+FJE 4Y3LL/II 0OC9JU0D0HT0HB2PR78+FFZI9$JAQJKLJLX2M*C5J4L*%NH$RS C95HFZIO MV5W49NTYPV9FH2V4KIJ.+O2NS4A7/HL KP8EFWKLHD4K%7TNP8EFYPVP/HI8402K7JO7NSK%7E1MWKP/HLIJL8JF8JF172ZOABUDHCE.FN/6A0ET.SE%R5Q4RAUMR+EF4GWR7UCS482DLVF$UQA10GH2L14ZP CZB*1A7GT4TA5 UULQUGLEN3FQMW6ULCW:1SWKSA20AV0%4'

data = 'HC1:NCFOXN.TSMAHN-H5YPXHQ7IRQ+Q*+R:JEQP4EXV25P*8H-%2$P4/0OAVDMFH6+0X6BMF6.UCOMIN6R%E5BD7CSO:CO+E4S8S8S0PPS VS1MM8BT7.Y7LV3DVBSO8: B G8Q/R1-JMZJ*8HX2T2%K:XF0GH.A5:S9395*CBVZ0K1H$$0CNN./GZJJ6Y2F2GQDF*ECUC7L85MB4O-OLG1/HL+X4XFDNLPBY4F82MKN4NN3F8PON+I3EYH$ON SI5K1*TB3:U-1V4AGGRJ5CB8X2+36D-I/2DBAJDAJCNB-43 X4VV2 73-E3GG3V20-7TZD5CC9T0HD0HCPNJZII7JSTNB95926+V4JW63X7U-O8:7T/5+Y5ST4U0PZW6-Z78T4 YPHUOJINQ+MN/Q19QE8QNQO%262NQLFK$UVN2O9BNH7R-C7+V2/$VNSF2CI%VR1:M:DA%EBAWNZXN/DF*FN.IT1TQ%OF7R9P7SEV7N/O2UFMPSA4LA*Q-R2*7D3$SR004H6$2'

b45_data = data[4:]
zlib_data = base45.b45decode(b45_data)
cose = zlib.decompress(zlib_data)
decoded_cose = CoseMessage.decode(cose)
payload = cbor2.loads(decoded_cose.payload)

print(payload)

def get_publickey(kid):
# Load certificates from file
with open('certs.json', 'rb') as file:
certs = json.load(file)

# Iterate through all the certs, and process if the correct kid is found
for c in certs:
if c['kid'] == base64.b64encode(kid).decode('utf-8'):
public_key = c['publicKey']
return public_key

# Using the decoded_cose object from the code above
algorithm = decoded_cose.get_attr(Algorithm).fullname
kid = decoded_cose.get_attr(KID)

public_key_b64 = get_publickey(kid)
der_public_key = base64.b64decode(public_key_b64)

public_key = load_der_public_key(der_public_key)
x = public_key.public_numbers().x.to_bytes(32, "big")
y = public_key.public_numbers().y.to_bytes(32, "big")

cose_key = EC2Key(crv='P_256', x=x, y=y, optional_params={'ALG': 'ES256'})
decoded_cose.key = cose_key
print(decoded_cose.verify_signature())

[Zahlesel]

итак имея рабочий код выше и прогоня по нему матиаса получаем

covpass-sdk admin$ python3 verify_my_certificate.py

{1: 'DE', 4: 1655542731, 6: 1624006731, -260: {1: {'v': [{'ci': 'URN:UVCI:01DE/A22011741/44I7RC30ESZ54KX83G1KCG#L', 'co': 'DE', 'dn': 2, 'dt': '2021-06-08', 'is': 'Robert Koch-Institut', 'ma': 'ORG-100030215', 'mp': 'EU/1/20/1528', 'sd': 2, 'tg': '840539006', 'vp': '1119349007'}], 'dob': '1954-05-06', 'nam': {'fn': 'Stolt', 'gn': 'Matthias Walter', 'fnt': 'STOLT', 'gnt': 'MATTHIAS<WALTER'}, 'ver': '1.0.0'}}}

------------------------------------------- kid -------------------------------------------------------

XkVWZqUeeFc=

--------------------------------------------------------------------------------------------------

------------------------------------------- public_key -------------------------------------------------------

MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEh934IiMCsXp977 pDeG7Wi11S+uGGoem6nSNbtCILcST4+/FqGlLOBJvIZPSh3hTHx2V7V+3Lzqi6R2dahOno/g==

--------------------------------------------------------------------------------------------------

------------------------------------------- X -------------------------------------------------------

b'\x87\xdd\xf8"#\x02\xb1z}\xef\xbaCxn\xd6\x8b]R\xfa\xe1\x86\xa1\xe9\xba\x9d#[\xb4"\x0bq$'

--------------------------------------------------------------------------------------------------

------------------------------------------- Y -------------------------------------------------------

b'\xf8\xfb\xf1j\x1aR\xce\x04\x9b\xc8d\xf4\xa1\xde\ x14\xc7\xc7e{W\xed\xcb\xce\xa8\xbaGgZ\x84\xe9\xe8\ xfe'

--------------------------------------------------------------------------------------------------

True

теперь нужно смотреть, каким макаром можно зашифровать с этим KID

ключ совершенно другой в отличие от работы с скриптом КУЭР

------------------------------------------- msg.key -------------------------------------------------------

<COSE_Key(EC2Key): {'EC2KpD': "b'\\x80\\x97\\x86P\\xca' ... (32 B)", 'EC2KpY': "b'\\x1b8\\xc3^k' ... (32 B)", 'EC2KpX': "b'/\\xc7\\x96\\xf7\\xf9' ... (32 B)", 'EC2KpCurve': 'P256', 'KpKty': 'KtyEC2', 'KpAlg': 'Es256'}>

--------------------------------------------------------------------------------------------------

------------------------------------------- cose_key2 -------------------------------------------------------

<COSE_Key(EC2Key): {'EC2KpY': "b'\\xf8\\xfb\\xf1j\\x1a' ... (32 B)", 'EC2KpX': 'b\'\\x87\\xdd\\xf8"#\' ... (32 B)', 'EC2KpCurve': 'P256', 'KpKty': 'KtyEC2', 'KpAlg': 'Es256'}>

--------------------------------------------------------------------------------------------------

CoseKey.from_dict(cose_key2) с таким ключем не работает
in compute_signature
ValueError: invalid literal for int() with base 16: b''

в рабочем варианте один хрен подпись не генерируется, можно только KID вписать
у меня KID к существующему приват ключу нет

<COSE_Sign1: [{'Algorithm': 'Es256', 'KID': b'S2V5NVJF'}, {}, b'\xa4\x01bXX' ... (263 B), b'' ... (0 B)]>

вот так должен выглядить рабочий

<COSE_Sign1: [{'Algorithm': 'Es256'}, {'KID': b'^EVf\xa5\x1exW'}, b'\xa4\x01bDE' ... (280 B), b'\x95,<\x90\x0b' ... (64 B)]>

в конце подпись

XkVWZqUeeFc= КИД у матиаса сверху был такой, это значит еще здесь заковыкочка с кодировкой

b'^EVf\xa5\x1exW' в косе
потом идет base64.b64encode( для поиска в листе ключей

[Zahlesel]

короче X и Y работают только для проверки ключа
для подписи же нужен приват кий

cose_key2 = EC2Key(crv='P_256', d=priv, optional_params={'ALG': 'ES256'})
msg.key = cose_key2

эквивалент

cose_key = {
KpKty: KtyEC2,
KpAlg: Es256, # ecdsa-with-SHA256
EC2KpCurve: P256, # Ought to be pk.curve - but the two libs clash
EC2KpD: priv,
}
msg.key = CoseKey.from_dict(cose_key)

подпись появляется у объекта после закодирования
out = msg.encode()
тут будет её видно
message = CoseMessage.decode(out)
print(message.signature)

поискать на просторах инета в кодах программ приватный ключик с кид_ид?
keyid = bytes('01234567', 'utf-8') # first 8 hex values of SHA256 fingerprint of signing certificate, not relevant for test

пока на этой стадии
https://raidforums.com/Thread-TRADIN...950#pid4200950

тут куча линков на баблик ключи и разные сертификаты
https://raw.githubusercontent.com/pa.../verify_ehc.py

def get_root_cert(source: str) -> x509.Certificate:
envvar = f'{source.replace("-", "_")}_ROOT_CERT'
value = os.getenv(envvar)
if value is None:
return ROOT_CERT_DOWNLOADERS[source]()

if value.startswith('-----BEGIN CERTIFICATE-----'):
return load_pem_x509_certificate(value.encode())
elif value.startswith('-----BEGIN PUBLIC KEY-----'):
pubkey = load_pem_public_key(value.encode())[URL="https://raidforums.com/Thread-TRADING-make-EU-green-pass?pid=4200950#pid4200950"][/URL]

также видим 3 способа валидасии файлом. рут сертификат, сертификат и паблик кий

валидируются на данный момент лиш два алгоритма

if alg == 'ES256':
# EC
x_bytes = b64decode(pub['x']) # type: ignore
y_bytes = b64decode(pub['y']) # type: ignore
x = int.from_bytes(x_bytes, byteorder="big", signed=False)
y = int.from_bytes(y_bytes, byteorder="big", signed=False)
crv: str = pub['crv'] # type: ignore
curve = NIST_CURVES[crv]()
ec_pubkey = EllipticCurvePublicNumbers(x, y, curve).public_key()
cert = HackCertificate(ec_pubkey, extensions=extensions)

elif alg == 'RS256':
# RSA
e_bytes = b64decode(pub['e']) # type: ignore
n_bytes = b64decode(pub['n']) # type: ignore
e = int.from_bytes(e_bytes, byteorder="big", signed=False)
n = int.from_bytes(n_bytes, byteorder="big", signed=False)
rsa_pubkey = RSAPublicNumbers(e, n).public_key()
cert = HackCertificate(rsa_pubkey, extensions=extensions)

[Zahlesel]

https://inza.wordpress.com/2021/05/3...n-authorities/

• OID 1.3.6.1.4.1.1847.2021.1.1 — valid for test
• OID 1.3.6.1.4.1.1847.2021.1.2 — valid for vaccinations
• OID 1.3.6.1.4.1.1847.2021.1.3 — valid for recovery

как я до сих пор понял данным нельзя улетать на сервер, храниться темболее. значит сервер должен слать ключ и КИД, а кодирование уже долно происходить локально в софте или в вебприложении

самая простая валидация это просто найти KEY_ID в листе провереных сертификатов

Note that Verifiers do not need to calculate the kid based on the DSC certificate and can

directly match the key identifier in issued health certificate with the kid on the trusted list.

https://ec.europa.eu/health/sites/de...ates_v1_en.pdf

как я понимаю валидация будет проходит посредством локального листа с паблик ключами, иначе изза проблем с инетом или сервером сервис проверки QR будет слишком проблематичен

интересно, что при генерировании приватного ключа здесь генерируется длинный KID
https://8gwifi.org/jwsgen.jsp
к нему же генерируется и паблик кий
получается, что это высер о котором я читал, мол каждый раз генерируется новый ключ
не думаю, что к одному приват ключу можно генерировать много паблик или наоборот.
только если они имели ввиду куер былбы разный тк время в секундах и нельзя один куэр два раза сгенерировать в одну секудну

непонятно, почему голландец удалил KID и потом вообще весь код со своей страницы
но не спрятал сам ключ. ведь можно было подсунуть любой ключ. или он ступил и показал рабочий? не думаю


https://ec.europa.eu/health/sites/de...ates_v4_en.pdf

исходим из того, что документ подписывается на сервере, но данные там не храняться
наверное не написали мол идет посыл личных данных, ато будет по жопе атата. а тут типо исключение из правил изза холеры 21го века