GOSTIM: P2P F2F E2EE IM ühe õhtu jooksul GOST-krüptograafiaga

Olen arendaja PyGOST raamatukogust (GOST-krüptograafilised primitiivid puhtal Pythonil), saan sageli küsimusi selle kohta, kuidas kiiresti rakendada kõige lihtsamat turvalist sõnumivahetust. Paljud arvavad, et rakenduskrüptograafia on piisavalt lihtne asi ja .encrypt() väljakutse plokkšifril on piisav, et turvaliselt edastada sõnumeid suhtluskanali kaudu. Teised aga usuvad, et rakenduskrüptograafia on vaid väheste privileeg ja on lubatav, et rikkad ettevõtted nagu Telegram, kellel on matemaatikaolümpia võitjad, ei suuda rakendada turvalist protokolli.

See kõik on inspireerinud mind kirjutama seda artiklit, et näidata, et krüptograafiliste protokollide ja turvalise IM-i rakendamine ei ole nii keeruline ülesanne. Siiski ei tasu leiutada oma autentimis- ja võtmevahetusprotokolle.

Artiklis käsitletakse peer-to-peer, friend-to-friend, lõpp-lõpuni krüptitud kiirsõnumiteenust koos SIGMA-I autentimise ja võtmevahetusprotokolliga (mille baasil on rakendatud IPsec IKE), kasutades ainult GOST-krüptograafilisi algoritme PyGOST raamatukogust ja ASN.1 koodimist sõnumite jaoks raamatukogust PyDERASN (mille kohta ma juba olen varem kirjutanud). Nõutav tingimus: see peab olema piisavalt lihtne, et seda saaks kirjutada nullist ühe õhtu (või tööpäeva) jooksul, vastasel juhul ei ole see enam lihtne programm. Tõenäoliselt sisaldab see vigu, liigset keerukust ja puudusi, lisaks on see minu esimene programm, kus kasutatakse asyncio teeki.

IM-i disain

Käivitamiseks peame mõtlema, milline meie IM välja näeb. Lihtsuse huvides olgu see peer-to-peer võrk, ilma mingisuguse osalejate avastamiseta. Üksikasjalikult näitame, millisele aadressile ja pordile me ühendust võtame, et suhelda vestluskaaslasega.

Ma mõistan, et hetkel on eeldus kahe suvalise arvuti vahelise otsese ühenduse kättesaadavuse osas praktiliselt rakendamisele suurt piirangut. Kuid mida rohkem arendajaid rakendavad igasuguseid NAT-traversali lahendusi, seda kauem me jääme IPv4 Internetti, masendava tõenäosusega ühenduse puudumisega suvaliste arvutite vahel. Kui kaua me peame taluma IPv6 puudumist kodus ja tööl?

Meil on sõbra-sõbrani võrk: kõik võimalikud vestluspartnerid peavad olema eelnevalt teada. Esiteks, see lihtsustab kõike: tutvustasime end, leidsime või ei leidnud nime/klahvi, lahkusime või jätkame tööd, teades vestluspartnerit. Teiseks, üldiselt on see ohutu ja välistab palju rünnakuid.

IM-liidese loomus jääb klassikaliste lahenduste lähedale. suckless-projektide, mis mulle väga meeldivad oma minimalismi ja Unix-way filosoofia tõttu. IM-programm loob iga vestluspartneri jaoks kausta, kus on kolm Unix domain socketit:

• in — sinna kirjutatakse saadetavad sõnumid vestluspartnerile;
• out — sealt loetakse vastu võetud sõnumeid vestluspartnerilt;
• state — selle kaudu loeme, kas vestluspartner on hetkel ühendatud, aadress/port ühendusest.

Lisaks luuakse conn socket, kuhu kirjutades hosti ja porti, algatame ühenduse kaugel asuva vestluspartneriga.

|-- alice
|   |-- in
|   |-- out
|   `-- state
|-- bob
|   |-- in
|   |-- out
|   `-- state
`- conn

Selline lähenemine võimaldab luua sõltumatuid IM-transportide ja kasutajaliidese realiseerimisi, sest igale maitsele ja värvusele ei saa meeldida, igale ei meeldi. Kasutades tmux ja/või multitail, saab luua mitmeakna vaate koos süntaktilise esiletõstmisega. Ja abiga rlwrap saab luua GNU Readline'i ühilduva sisestusrea sõnumite jaoks.

Tegelikult kasutavad suckless projektid FIFO-faile. Isiklikult ei suutnud ma mõista, kuidas asyncio's faile korraga kasutada ilma eraldi niitide käsitsi seadistamiseta (selliseks otstarbeks olen pikka aega kasutanud keelt Go). Seetõttu otsustasin kasutada Unix domain sokette. Kahjuks takistab see teha echo 2001:470:dead::babe 6666 > conn. Otsustasin selle probleemi lahendada, kasutades socat: echo 2001:470:dead::babe 6666 | socat — UNIX-CONNECT:conn, socat READLINE UNIX-CONNECT:alice/in.

Algne ebaohutu protokoll

Transportina kasutatakse TCP-d: see tagab kohaletoimetamise ja selle järjekorra. UDP ei garanteeri kumbagi (mis oleks kasulik, kui rakendatakse krüptograafiat), ja toetust SCTP Pythonis ei ole vaikimisi.

Kahjuks ei ole TCP-s mõistet, mis oleks sõnum, vaid ainult baitide voog. Seetõttu tuleb välja mõelda formaat sõnumite jaoks, et neid voos eristada. Saame kokku leppida, et kasutame reavahetust. Alustuseks sobib see hästi, kuid kui hakkame meie sõnumeid krüpteerima, võib see sümbol ilmuda kuskil krüpteeritud tekstis. Seetõttu on võrkudes populaarsed protokollid, mis saadavad esmalt sõnumi pikkuse baitides. Näiteks Pythonis on olemas xdrlib, mis võimaldab sellise formaadiga töötada. XDR.

Me ei tööta TCP lugemisega korralikult ja tõhusalt — lihtsustame koodi. Loeme lõputu tsükli jooksul andmeid soketist, kuni dekodeerime täispika sõnumi. Sellise lähenemisviisi jaoks saab kasutada ka JSON-i koos XML-iga. Kuid kui lisandub krüptograafia, tuleb andmed allkirjastada ja autentida — see nõuab bait-baidiga identset objekti esitlemist, mida JSON/XML ei taga (dumpsi tulemus võib erineda).

XDR sobib selle ülesande jaoks, kuid ma valin ASN.1 DER-kodeeringuga. PyDERASN raamatukogu, sest meil on käsitlemiseks kõrgematasemelised objektid, millega on sageli meeldivam ja mugavam töötada. Erinevalt schemaless-st bencode, MessagePack või CBOR, ASN.1 kontrollib automaatselt andmeid vastavalt rangelt määratud skeemile.

# Msg ::= CHOICE {
#       text      MsgText,
#       handshake [0] EXPLICIT MsgHandshake }
class Msg(Choice):
    schema = ((
        ("text", MsgText()),
        ("handshake", MsgHandshake(expl=tag_ctxc(0))),
    ))

# MsgText ::= SEQUENCE {
#       text UTF8String (SIZE(1..MaxTextLen))}
class MsgText(Sequence):
    schema = ((
        ("text", UTF8String(bounds=(1, MaxTextLen))),
    ))

# MsgHandshake ::= SEQUENCE {
#       peerName UTF8String (SIZE(1..256)) }
class MsgHandshake(Sequence):
    schema = ((
        ("peerName", UTF8String(bounds=(1, 256))),
    ))

Saadetav sõnum on Msg: kas tekstiline MsgText (praegu ühes tekstiväljas), või sõnumikätlemine MsgHandshake (kus edastatakse vestluspartneri nimi). Praegu tundub see ülemäära keeruline, kuid see on tulevikku suunatud lahendus.

     ┌─────┐            ┌─────┐
     │PeerA│            │PeerB│
     └──┬──┘            └──┬──┘
        │MsgHandshake(IdA) │
        │─────────────────>│
        │                  │
        │MsgHandshake(IdB) │
        ││
        │                  │
        │    MsgText()     │
        │<─────────────────│
        │                  │

IM ilma krüptograafiata

Kuidas ma juba ütlesin, kõigi soketite operatsioonide jaoks kasutatakse asyncio raamatukogu. Teeme eeldusi, mida me oodata saame käivitamisel:

parser = argparse.ArgumentParser(description="GOSTIM")
parser.add_argument(
    "--our-name",
    required=True,
    help="Meie kaaslase nimi",
)
parser.add_argument(
    "--their-names",
    required=True,
    help="Nende kaaslaste nimed, eraldatud komaga",
)
parser.add_argument(
    "--bind",
    default="::1",
    help="Aadress, millel kuulata",
)
parser.add_argument(
    "--port",
    type=int,
    default=6666,
    help="Port, millel kuulata",
)
args = parser.parse_args()
OUR_NAME = UTF8String(args.our_name)
THEIR_NAMES = set(args.their_names.split(","))

Määrake oma nimi (—our-name alice). Kõiki oodatavaid kaaslasi loetletakse komaga (—their-names bob,eve). Iga kaaslase jaoks luuakse Unix-soketide kaust, samuti korutine iga in, out, state jaoks:

for peer_name in THEIR_NAMES:
    makedirs(peer_name, mode=0o700, exist_ok=True)
    out_queue = asyncio.Queue()
    OUT_QUEUES[peer_name] = out_queue
    asyncio.ensure_future(asyncio.start_unix_server(
        partial(unixsock_out_processor, out_queue=out_queue),
        path.join(peer_name, "out"),
    ))
    in_queue = asyncio.Queue()
    IN_QUEUES[peer_name] = in_queue
    asyncio.ensure_future(asyncio.start_unix_server(
        partial(unixsock_in_processor, in_queue=in_queue),
        path.join(peer_name, "in"),
    ))
    asyncio.ensure_future(asyncio.start_unix_server(
        partial(unixsock_state_processor, peer_name=peer_name),
        path.join(peer_name, "state"),
    ))
asyncio.ensure_future(asyncio.start_unix_server(unixsock_conn_processor, "conn"))

Kasutajalt saadud sõnumid in soketist saadetakse IN_QUEUES järjekordadesse:

async def unixsock_in_processor(reader, writer, in_queue: asyncio.Queue) -> None:
    while True:
        text = await reader.read(MaxTextLen)
        if text == b"":
            break
        await in_queue.put(text.decode("utf-8"))

Vestlused, mille saadame OUT_QUEUES järjekordadesse, saadetakse välja soketisse:

async def unixsock_out_processor(reader, writer, out_queue: asyncio.Queue) -> None:
    while True:
        text = await out_queue.get()
        writer.write(("[%s] %s" % (datetime.now(), text)).encode("utf-8"))
        await writer.drain()

State soketist lugemisel otsib programm PEER_ALIVE sõnastikust ühenduse partneri aadressi. Kui ühendust partneriga ei ole, kirjutatakse välja tühi rida.

async def unixsock_state_processor(reader, writer, peer_name: str) -> None:
    peer_writer = PEER_ALIVES.get(peer_name)
    writer.write(
        b"" if peer_writer is None else (" ".join([
            str(i) for i in peer_writer.get_extra_info("peername")[:2]
        ]).encode("utf-8") + b"n")
    )
    await writer.drain()
    writer.close()

Aadressi kirjutamisel conn soketti käivitatakse ühenduse "algataja" funktsioon:

async def unixsock_conn_processor(reader, writer) -> None:
    data = await reader.read(256)
    writer.close()
    host, port = data.decode("utf-8").split(" ")
    await initiator(host=host, port=int(port))

Vaatame algatajat. Esiteks avab ta, nagu tavaliselt, ühenduse määratud hosti/portiga ja saadab käivitamisõiguse sõnumi koos oma nimega:

 130 async def initiator(host, port):
 131     _id = repr((host, port))
 132     logging.info("%s: dialimine", _id)
 133     reader, writer = await asyncio.open_connection(host, port)
 134     # Käepideme sõnum {{{
 135     writer.write(Msg(("käepide", MsgHandshake((
 136         ("partneriNimi", OUR_NAME),
 137     )))).encode())
 138     # }}}
 139     await writer.drain()

Seejärel ootab see vastust kaugserverilt. Püüab dekodeerida saadud vastust Msg ASN.1 skeemi järgi. Eeldame, et kogu sõnum saadetakse ühes TCP-segmente ja me saame selle aatomiliselt kätte, kui kutsume välja .read(). Kontrollime, et oleme saanud tõepoolest käepideme sõnumi.

 141     # Oota käepideme sõnumit {{{
 142     data = await reader.read(256)
 143     if data == b"":
 144         logging.warning("%s: ei ole vastust, katke ühendus", _id)
 145         writer.close()
 146         return
 147     try:
 148         msg, _ = Msg().decode(data)
 149     except ASN1Error:
 150         logging.warning("%s: dekodeerimata vastus, katke ühendus", _id)
 151         writer.close()
 152         return
 153     logging.info("%s: saadi %s sõnum", _id, msg.choice)
 154     if msg.choice != "käepide":
 155         logging.warning("%s: ootamatu sõnum, katke ühendus", _id)
 156         writer.close()
 157         return
 158     # }}}

Kontrollime, kas me teame kõnekaaslase saadetud nime. Kui ei, katkestame ühenduse. Kontrollime, kas meil on juba temaga ühendus loodud (kõnekaaslane on taas andnud käsu meiega ühendada) ja sulgeme selle. IN_QUEUES järjekorda pannakse Python-read sõnumiga, kuid eriliseks väärtuseks on None, mis annab märku msg_sender koorutine lõpetada töö, et ta unustaks oma writer, mis on seotud aegunud TCP-ühendusega.

 159     msg_handshake = msg.value
 160     peer_name = str(msg_handshake["peerName"])
 161     if peer_name not in THEIR_NAMES:
 162         logging.warning("tundmatu kõnekaaslase nimi: %s", peer_name)
 163         writer.close()
 164         return
 165     logging.info("%s: sessioon loodud: %s", _id, peer_name)
 166     # Käivita tekstisõnumite saatja, initsialiseeri transport dekooder {{{
 167     peer_alive = PEER_ALIVES.pop(peer_name, None)
 168     if peer_alive is not None:
 169         peer_alive.close()
 170         await IN_QUEUES[peer_name].put(None)
 171     PEER_ALIVES[peer_name] = writer
 172     asyncio.ensure_future(msg_sender(peer_name, writer))
 173     # }}}

msg_sender võtab vastu väljuvaid sõnumeid (mis pannakse järjekorda in soketist), serialiseerib need MsgText sõnumiks ja saadab TCP-ühenduse kaudu. See võib igal hetkel katkeda — seda me selgelt püüame kinni.

async def msg_sender(peer_name: str, writer) -> None:
    in_queue = IN_QUEUES[peer_name]
    while True:
        text = await in_queue.get()
        if text is None:
            break
        writer.write(Msg(("text", MsgText((
            ("text", UTF8String(text)),
        )))).encode())
        try:
            await writer.drain()
        except ConnectionResetError:
            del PEER_ALIVES[peer_name]
            return
        logging.info("%s: sent %d characters message", peer_name, len(text))

Lõpus siseneb algataja lõputusse tsüklisse, lugedes sõnumeid soketist. Kontrollib, kas need on tekstisõnumid, ja paneb need OUT_QUEUES järjekorda, kust need saadetakse välja vastava vestluspartneri soketti. Miks ei saa lihtsalt teha .read() ja sõnumit dekodeerida? Sest ei saa välistada olukorda, kus mitu kasutaja sõnumit liidetakse operatsioonisüsteemi puhvris ja saadetakse ühes TCP-segmendis. Dekodeerida saame me esimese, kuid puhvris võib jääda osa järgnevast. Igasuguste anomaaliate korral suletakse TCP-ühendus ja peatatakse msg_sender korutii, saates OUT_QUEUES järjekorda None.

 174     buf = b""
 175     # Oota testisõnumeid {{{
 176     while True:
 177         data = await reader.read(MaxMsgLen)
 178         if data == b"":
 179             break
 180         buf += data
 181         if len(buf) > MaxMsgLen:
 182             logging.warning("%s: maksimaalne puhver suurus ületatud", _id)
 183             break
 184         try:
 185             msg, tail = Msg().decode(buf)
 186         except ASN1Error:
 187             continue
 188         buf = tail
 189         if msg.choice != "text":
 190             logging.warning("%s: ootamatu %s sõnum", _id, msg.choice)
 191             break
 192         try:
 193             await msg_receiver(msg.value, peer_name)
 194         except ValueError as err:
 195             logging.warning("%s: %s", err)
 196             break
 197     # }}}
 198     logging.info("%s: katkestamine: %s", _id, peer_name)
 199     IN_QUEUES[peer_name].put(None)
 200     writer.close()

  66 async def msg_receiver(msg_text: MsgText, peer_name: str) -> None:
  67     text = str(msg_text["text"])
  68     logging.info("%s: saadud %d tähemärki sõnum", peer_name, len(text))
  69     await OUT_QUEUES[peer_name].put(text)

Lähme tagasi põhikoodi juurde. Pärast kõigi korutinate loomist programmi käivitamise hetkel loome TCP-serveri. Iga kehtestatud ühenduse korral loob see responder (vastaja) korutina.

logging.basicConfig(
    level=logging.INFO,
    format="%(levelname)s %(asctime)s: %(funcName)s: %(message)s",
)
loop = asyncio.get_event_loop()
server = loop.run_until_complete(asyncio.start_server(responder, args.bind, args.port))
logging.info("Külastatakse: %s", server.sockets[0].getsockname())
loop.run_forever()

responder sarnaneb initiatorile ja peegeldab kõiki samu toiminguid, kuid lõpmatu sõnumite lugemise tsükkel käivitatakse kohe, lihtsuse huvides. Praegu saadab käepigistusprotokoll igast küljest ühe sõnumi, kuid tulevikus saadetakse algataja poolt kaks sõnumit, millele järgneb kohene tekstisõnumite saatmise võimalus.

  72 async def responder(reader, writer):
  73     _id = writer.get_extra_info("peername")
  74     logging.info("%s: connected", _id)
  75     buf = b""
  76     msg_expected = "handshake"
  77     peer_name = None
  78     while True:
  79         # Read until we get Msg message {{{
  80         data = await reader.read(MaxMsgLen)
  81         if data == b"":
  82             logging.info("%s: closed connection", _id)
  83             break
  84         buf += data
  85         if len(buf) > MaxMsgLen:
  86             logging.warning("%s: max buffer size exceeded", _id)
  87             break
  88         try:
  89             msg, tail = Msg().decode(buf)
  90         except ASN1Error:
  91             continue
  92         buf = tail
  93         # }}}
  94         if msg.choice != msg_expected:
  95             logging.warning("%s: unexpected %s message", _id, msg.choice)
  96             break
  97         if msg_expected == "text":
  98             try:
  99                 await msg_receiver(msg.value, peer_name)
 100             except ValueError as err:
 101                 logging.warning("%s: %s", err)
 102                 break
 103         # Process Handshake message {{{
 104         elif msg_expected == "handshake":
 105             logging.info("%s: got %s message", _id, msg_expected)
 106             msg_handshake = msg.value
 107             peer_name = str(msg_handshake["peerName"])
 108             if peer_name not in THEIR_NAMES:
 109                 logging.warning("unknown peer name: %s", peer_name)
 110                 break
 111             writer.write(Msg(("handshake", MsgHandshake((
 112                 ("peerName", OUR_NAME),
 113             )))).encode())
 114             await writer.drain()
 115             logging.info("%s: session established: %s", _id, peer_name)
 116             peer_alive = PEER_ALIVES.pop(peer_name, None)
 117             if peer_alive is not None:
 118                 peer_alive.close()
 119                 await IN_QUEUES[peer_name].put(None)
 120             PEER_ALIVES[peer_name] = writer
 121             asyncio.ensure_future(msg_sender(peer_name, writer))
 122             msg_expected = "text"
 123         # }}}
 124     logging.info("%s: disconnecting", _id)
 125     if msg_expected == "text":
 126         IN_QUEUES[peer_name].put(None)
 127     writer.close()

Turvaline protokoll

On aeg tagada meie suhtluse turvalisus. Mida me julgeolekuga silmas peame ja mida soovime:

• edastatud sõnumite konfidentsiaalsus;
• edastatud sõnumite autentsus ja terviklikkus — nende muutmine peaks olema tuvastatav;
• kaitse taaskäivitamisrünnakute (replay attack) eest — sõnumite kadumise või kordumise fakt peab olema avastatav (ja me otsustame katkestada ühenduse);
• kaasvestlejate tuvastamine ja autentimine eelnevalt sisestatud avalike võtmete põhjal — oleme juba otsustanud luua sõbralt-sõbrale võrgu. Ainult pärast autentimist mõistame, kellega suhtleme;
• olemasolu täiuslik edasiulatuv salajasus omadused (PFS) — meie pikaajalise allkirja võtme kompromiteerimine ei tohi võimaldada kogu varasema kirjavahetuse lugemist. Salvestatud sissetungitud liiklus muutub kasutuks;
• sõnumite (transpordi ja kätlemise) kehtivus/valiidus ainult ühe TCP-seansi piires. Teise seansi (isegi sama kaasvestlejaga) õigesti allkirjastatud/autentitud sõnumite sisestamine ei tohi olla võimalik;
• passiivne vaatleja ei tohiks näha ei kasutajaid, ei toimetatavaid pikaealisi avalikke võtmeid, ei ka nende räsimärke. Teatud anonymiteet passiivse vaatleja eest.

Üllatav, et seda minimaalset taset soovivad kõik igasuguste käepigistusprotokollide puhul, kuid vähe sellest tegelikult rakendatakse "koduseid" protokolle. Seega, jätame uue välja mõtlemise. Soovitaksin kindlalt kasutada Noise framework protokollide loomiseks, kuid valime midagi lihtsamat.

Kaks protokolli on eriti populaarsed:

• TLS — keeruline protokoll, millel on pikk ajaloo hulk vigu, puudujääke, haavatavusi, halba planeerimist, keerukust ja ebatäiuslikkust (kuigi TLS 1.3-ga see pole kuigi seotud). Kuid me ei käsitle seda ülekompleksuse tõttu.
• IPsec koos IKE — ei oma tõsiseid krüptograafilisi probleeme, kuigi nadki ei ole lihtsad. Kui lugeda IKEv1 ja IKEv2 kohta, siis nende allikaks on STS, ISO/IEC IS 9798-3 ja SIGMA (SIGn-and-MAc) protokollid — piisavalt lihtsad rakendamiseks ühe õhtu jooksul.

Miks on SIGMA, kui viimane etapp STS/ISO protokollide arengus, hea? See vastab meie kõikidele nõudmistele (sealhulgas vestluspartnerite identifikaatorite "peitmisele"), tal ei ole tuntud krüptograafilisi probleeme. See on minimalistlik — protokolli sõnumist vähemalt ühe elementi eemaldamine muudab selle ebaturvaliseks.

Alustame kõige lihtsamatest kodutooted protokollidest ja liigume SIGMA poole. Meid huvitav kõige baasem operatsioon on võtme kokkusobivus: funktsioon, mille väljundiks on sama väärtus, mille saavad mõlemad osalised, mida saab kasutada sümmeetrilise võtmena. Ilma detailidesse laskumata: iga osaline genereerib efemeerse (ainult ühe seansi jooksul kasutatava) võtme paari (avalik ja privaatne võti), vahetavad avalikke võtmeid, kutsuvad esile kokkusobivuse funktsiooni, kuhu nad edastavad oma privaatvõtme ja vestluspartneri avaliku võtme.

┌─────┐          ┌─────┐
│PeerA│          │PeerB│
└──┬──┘          └──┬──┘
   │   IdA, PubA    │ ╔════════════════════╗
   │───────────────>│ ║PrvA, PubA = DHgen()║
   │                │ ╚════════════════════╝
   │   IdB, PubB    │ ╔════════════════════╗
   │<───────────────│ ║PrvB, PubB = DHgen()║
   │                │ ╚════════════════════╝
   ────┐    ╔═══════╧════════════╗
       │    ║Key = DH(PrvA, PubB)║
   <───┘    ╚═══════╤════════════╝
   │                │
   │                │

Keenest saatus võib vahele segada ja asendada avalikke võtmeid oma omadega — selles protokollis ei ole partnerite autentimist. Lisame allkirja pikaealiste võtmetega.

┌─────┐                            ┌─────┐
│PeerA│                            │PeerB│
└──┬──┘                            └──┬──┘
   │IdA, PubA, sign(SignPrvA, (PubA)) │ ╔═══════════════════════════╗
   │─────────────────────────────────>| ║SignPrvA, SignPubA = load()║
   │                                  │ ║PrvA, PubA = DHgen()       ║
   │                                  │ ╚═══════════════════════════╝
   │IdB, PubB, sign(SignPrvB, (PubB)) │ ╔═══════════════════════════╗
   │<─────────────────────────────────│ ║SignPrvB, SignPubB = load()║
   │                                  │ ║PrvB, PubB = DHgen()       ║
   │                                  │ ╚═══════════════════════════╝
   ────┐    ╔═════════════════════╗   │
       │    ║verify(SignPubB, ...)║   │
   <───┘    ║Key = DH(PrvA, PubB) ║   │
   │        ╚═════════════════════╝   │
   │                                  │

Selline allkiri ei sobi, kuna see ei ole seotud konkreetse sessiooniga. Sellised sõnumid võivad sobida ka teiste osalejatega sessioonide jaoks. Allkirjastamine peab toimuma kogu konteksti ulatuses. See sunnib ka A-l veel ühe sõnumi saatmist.

Lisaks on kriitiline, et allkirja alla lisataks koostisosade ja unikaalse identifikaator, vastasel juhul võime IdXXX asendada ja allkirjastada sõnumi kellegi teise teadliku võtmega. Selle vältimiseks reflection rünnakute, peab allkirja all olevate elementide paiknemine olema selgelt määratletud: kui A allkirjastab (PubA, PubB), siis peab B allkirjastama (PubB, PubA). See rõhutab ka andmesarjade struktuuri ja formaadi valimise tähtsust. Näiteks ASN.1 DER kodeerimise kogumid sorteeritakse: SET OF(PubA, PubB) on identne SET OF(PubB, PubA).

┌─────┐                                       ┌─────┐
│PeerA│                                       │PeerB│
└──┬──┘                                       └──┬──┘
   │                 IdA, PubA                   │ ╔═══════════════════════════╗
   │────────────────────────────────────────────>│ ║SignPrvA, SignPubA = load()║
   │                                             │ ║PrvA, PubA = DHgen()       ║
   │                                             │ ╚═══════════════════════════╝
   │IdB, PubB, sign(SignPrvB, (IdB, PubA, PubB)) │ ╔═══════════════════════════╗
   │<────────────────────────────────────────────│ ║SignPrvB, SignPubB = load()║
   │                                             │ ║PrvB, PubB = DHgen()       ║
   │                                             │ ╚═══════════════════════════╝
   │     sign(SignPrvA, (IdA, PubB, PubA))       │ ╔═════════════════════╗
   │────────────────────────────────────────────>│ ║verify(SignPubB, ...)║
   │                                             │ ║Key = DH(PrvA, PubB) ║
   │                                             │ ╚═════════════════════╝
   │                                             │

Kuid me ei ole veel "tõestanud", et oleme selle seansi jaoks sama üldise võtme välja töötanud. Põhimõtteliselt saaksime sellest sammust ka loobuda — esimene edastatav sõnum on kehtetu, kuid tahame, et pärast käepigistuse lõppemist oleksime kindlad, et kõik on tõeliselt kooskõlastatud. Praegu tugineme ISO/IEC IS 9798-3 protokollile.

Me võiksime allkirjastada ka välja töötatud võtme. See on ohtlik, kuna on võimalik, et kasutatud allkirjastamisalgoritmis võivad olla lekked (kuigi allkirja bitti, kuid ikkagi lekked). Saame allkirjastada välja töötatud võtme räsima, kuid isegi räsimise leke välja töötatud võtme puhul võib olla väärtus, kui rünnata genereerimise funktsiooni brute-force meetodil. SIGMA kasutab MAC-funktsiooni, mis autentib saatja identifikaatori.

┌─────┐                                            ┌─────┐
│PeerA│                                            │PeerB│
└──┬──┘                                            └──┬──┘
   │                    IdA, PubA                     │ ╔═══════════════════════════╗
   │─────────────────────────────────────────────────〉│ ║SignPrvA, SignPubA = load()║
   │                                                  │ ║PrvA, PubA = DHgen()       ║
   │                                                  │ ╚═══════════════════════════╝
   │IdB, PubB, sign(SignPrvB, (PubA, PubB)), MAC(IdB) │ ╔═══════════════════════════╗
   │〈─────────────────────────────────────────────────│ ║SignPrvB, SignPubB = load()║
   │                                                  │ ║PrvB, PubB = DHgen()       ║
   │                                                  │ ╚═══════════════════════════╝
   │                                                  │ ╔═════════════════════╗
   │     sign(SignPrvA, (PubB, PubA)), MAC(IdA)       │ ║Key = DH(PrvA, PubB) ║
   │─────────────────────────────────────────────────〉│ ║verify(Key, IdB)     ║
   │                                                  │ ║verify(SignPubB, ...)║
   │                                                  │ ╚═════════════════════╝
   │                                                  │

Optimeerimise osas võivad mõned soovida oma efemeerseid võtmeid uuesti kasutada (mida on loomulikult kahju teha PFS-i jaoks). Näiteks, kui genereerisime võtme paari, üritasime ühenduda, kuid TCP ei olnud saadaval või katkestas kuskil protokolli keskel. Kahju on raisata kulutatud entropiat ja protsessorite ressursse uue paari jaoks. Seetõttu tutvustame nn küpsist — pseudojuhuslikku väärtust, mis kaitseb võimalike juhuslike taaskasutamise rünnakute eest, kui efemeerseid avalikke võtmeid uuesti kasutatakse. Tänu küpsise ja efemeerse avaliku võtme vahelisele sidumisele saab vastase avaliku võtme allkirjastamise mõttetuks jätta.

┌─────┐                                                                 ┌─────┐
│PeerA│                                                                 │PeerB│
└──┬──┘                                                                 └──┬──┘
   │                          IdA, PubA, CookieA                           │ ╔═══════════════════════════╗
   │──────────────────────────────────────────────────────────────────────>│ ║SignPrvA, SignPubA = load()║
   │                                                                       │ ║PrvA, PubA = DHgen()       ║
   │                                                                       │ ╚═══════════════════════════╝
   │IdB, PubB, CookieB, sign(SignPrvB, (CookieA, CookieB, PubB)), MAC(IdB) │ ╔═══════════════════════════╗
   ││ ║verify(Key, IdB)     ║
   │                                                                       │ ║verify(SignPubB, ...)║
   │                                                                       │ ╚═════════════════════╝
   │                                                                       │

Lõ finally m we want to protect the privacy of our interlocutor identifiers from passive observers. For this, SIGMA proposes first to exchange ephemeral keys, develop a shared key to encrypt authenticating and identifying messages. SIGMA describes two options:

• SIGMA-I — protects the initiator from active attacks and the respondent from passive ones: the initiator authenticates the respondent, and if something does not match, he does not reveal his identification. The respondent, however, reveals his identification only if the active protocol is initiated. A passive observer learns nothing;
  SIGMA-R — protects the respondent from active attacks and the initiator from passive ones. Everything is the opposite, but in this protocol, four handshake messages are transmitted.

  Valime SIGMA-I, kuna see on rohkem sarnane sellele, mida me ootame kliendi-serveri tavapärastest lahendustest: klient tunneb ära ainult autentitud serveri, samas kui server teab kõike. Lisaks on see rakendamisel lihtsam, kuna vajalike käepigistuste sõnumite arv on väiksem. Kõik, mida me protokolli lisame, on sõnumi osa krüpteerimine ja A identifikaatori edastamine viimase sõnumi krüpteeritud osas:

  ┌─────┐                                                                        ┌─────┐
  │PeerA│                                                                        │PeerB│
  └──┬──┘                                                                        └──┬──┘
     │                                PubA, CookieA                                 │ ╔═══════════════════════════╗
     │─────────────────────────────────────────────────────────────────────────────>| ║SignPrvA, SignPubA = load()║
     │                                                                              │ ║PrvA, PubA = DHgen()       ║
     │                                                                              │ ╚═══════════════════════════╝
     │PubB, CookieB, Enc((IdB, sign(SignPrvB, (CookieA, CookieB, PubB)), MAC(IdB))) │ ╔═══════════════════════════╗
     │| ║verify(Key, IdB)     ║
     │                                                                              │ ║verify(SignPubB, ...)║
     │                                                                              │ ╚═════════════════════╝
     │                                                                              │
  

  • Allkirjastamiseks kasutatakse GOST R 34.10-2012 algoritmi 256-bitiste võtmetega.
  • Ühise võtme genereerimiseks kasutatakse 34.10-2012 VKO.
  • MAC-ina kasutatakse CMAC-i. Tehniliselt on see plokkšifri töörežiim, mida kirjeldatakse GOST R 34.13-2015. Selle režiimi krüpteerimisfunktsioonina — Sääse (34.12-2015).
  • Vestluspartneri identifikaatorina kasutatakse tema avaliku võtme hash'i. Hashina kasutatakse Stribog-256 (34.11-2012 256 bitti).

  Pärast käepigistust on meil kokkulepitud ühine võti. Seda saame kasutada autentitud transportside krüpteerimiseks. See osa on täiesti lihtne ja selles on keeruline eksida: suurendame sõnumite loendurit, krüpteerime sõnumi, autentime (MAC) loenduri ja krüpteeritud teksti, saadame. Sõnumi vastuvõtmisel kontrollime, et loendur on oodatud väärtusega, autentime krüpteeritud teksti loenduri abil, dekrüpteerime. Millise võtmega krüpteerida käepigistuse, transpordi sõnumid, mida autentida? Ühte võtmega kõikide nende ülesannete täitmiseks kasutamine on ohtlik ja arutu. Tuleb genereerida võtmeid, kasutades spetsialiseeritud funktsioone KDF (key derivation function). Jätke see lihtsaks, ei hakka midagi välja mõtlema: HKDF on ammu tuntud, hästi uuritud ja sellel ei ole teadaolevaid probleeme. Kahjuks ei ole selle funktsiooni jaoks Pytonis sisseehitatud teeki, seega kasutame hkdf paketti. HKDF kasutab seespoolt HMAC, mis omakorda kasutab räsifunktsiooni. Näide Python’i rakendamisest on Wikipedia lehe peal vaid mõned koodiread. Nagu 34.10-2012 puhul, kasutame räsifunktsioonina Stribog-256. Meie võtme kooskõlastamise funktsiooni väljundit nimetatakse seansivõtmiseks, millest genereeritakse puuduolevad sümmeetrilised:

  kdf = Hkdf(None, key_session, hash=GOST34112012256)
  kdf.expand(b"handshake1-mac-identity")
  kdf.expand(b"handshake1-enc")
  kdf.expand(b"handshake1-mac")
  kdf.expand(b"handshake2-mac-identity")
  kdf.expand(b"handshake2-enc")
  kdf.expand(b"handshake2-mac")
  kdf.expand(b"transport-initiator-enc")
  kdf.expand(b"transport-initiator-mac")
  kdf.expand(b"transport-responder-enc")
  kdf.expand(b"transport-responder-mac")
  

  Struktuurid/schema

  Vaadakem, millised ASN.1 struktuurid meil nüüd on, et edastada kõik need andmed:

  class Msg(Choice):
      schema = ((
          ("text", MsgText()),
          ("handshake0", MsgHandshake0(expl=tag_ctxc(0))),
          ("handshake1", MsgHandshake1(expl=tag_ctxc(1))),
          ("handshake2", MsgHandshake2(expl=tag_ctxc(2))),
      ))
  
  class MsgText(Sequence):
      schema = ((
          ("payload", MsgTextPayload()),
          ("payloadMac", MAC()),
      ))
  
  class MsgTextPayload(Sequence):
      schema = ((
          ("nonce", Integer(bounds=(0, float("+inf")))),
          ("ciphertext", OctetString(bounds=(1, MaxTextLen))),
      ))
  
  class MsgHandshake0(Sequence):
      schema = ((
          ("cookieInitiator", Cookie()),
          ("pubKeyInitiator", PubKey()),
      ))
  
  class MsgHandshake1(Sequence):
      schema = ((
          ("cookieResponder", Cookie()),
          ("pubKeyResponder", PubKey()),
          ("ukm", OctetString(bounds=(8, 8))),
          ("ciphertext", OctetString()),
          ("ciphertextMac", MAC()),
      ))
  
  class MsgHandshake2(Sequence):
      schema = ((
          ("ciphertext", OctetString()),
          ("ciphertextMac", MAC()),
      ))
  
  class HandshakeTBE(Sequence):
      schema = ((
          ("identity", OctetString(bounds=(32, 32))),
          ("signature", OctetString(bounds=(64, 64))),
          ("identityMac", MAC()),
      ))
  
  class HandshakeTBS(Sequence):
      schema = ((
          ("cookieTheir", Cookie()),
          ("cookieOur", Cookie()),
          ("pubKeyOur", PubKey()),
      ))
  
  class Cookie(OctetString): bounds = (16, 16)
  class PubKey(OctetString): bounds = (64, 64)
  class MAC(OctetString): bounds = (16, 16)
  

  HandshakeTBS — see, what will be signed (to be signed). HandshakeTBE — see, what will be encrypted (to be encrypted). I want to draw attention to the ukm field in MsgHandshake1. 34.10 VKO, for even greater randomization of generated keys, includes the parameter UKM (user keying material) — just extra entropy.

  Krüptograafia lisamine koodile

  Käsitleme ainult originaalkoodis tehtud muudatusi, kuna raamistik on jäänud samaks (tegelikult loodi kõigepealt lõplik teostus ja siis eemaldati sellest kogu krüptograafia).

  Kuna autentimine ja suhtluse identifitseerimine toimub avalike võtmete alusel, tuleb neid nüüd kusagil pikaajaliselt hoida. Lihtsuse huvides kasutame sellist tüüpi JSON-i:

  {
      "our": {
          "prv": "21254cf66c15e0226ef2669ceee46c87b575f37f9000272f408d0c9283355f98",
          "pub": "938c87da5c55b27b7f332d91b202dbef2540979d6ceaa4c35f1b5bfca6df47df0bdae0d3d82beac83cec3e353939489d9981b7eb7a3c58b71df2212d556312a1"
      },
      "their": {
          "alice": "d361a59c25d2ca5a05d21f31168609deeec100570ac98f540416778c93b2c7402fd92640731a707ec67b5410a0feae5b78aeec93c4a455a17570a84f2bc21fce",
          "bob": "aade1207dd85ecd283272e7b69c078d5fae75b6e141f7649ad21962042d643512c28a2dbdc12c7ba40eb704af920919511180c18f4d17e07d7f5acd49787224a"
      }
  }
  

  our — meie võtmepaar, heksakraadilised privaatne ja avalik võti. their — vestluspartnerite nimed ja nende avalikud võtmed. Muudame käsurea argumente ja lisame JSON andmete postitöötluse:

  from pygost import gost3410
  from pygost.gost34112012256 import GOST34112012256
  
  CURVE = gost3410.GOST3410Curve(
      *gost3410.CURVE_PARAMS["GostR3410_2001_CryptoPro_A_ParamSet"]
  )
  
  parser = argparse.ArgumentParser(description="GOSTIM")
  parser.add_argument(
      "--keys-gen",
      action="store_true",
      help="Loo JSON uue võtmepaariga",
  )
  parser.add_argument(
      "--keys",
      default="keys.json",
      required=False,
      help="JSON meie ja nende võtmetega",
  )
  parser.add_argument(
      "--bind",
      default="::1",
      help="Aadress, millel kuulata",
  )
  parser.add_argument(
      "--port",
      type=int,
      default=6666,
      help="Port, millel kuulata",
  )
  args = parser.parse_args()
  
  if args.keys_gen:
      prv_raw = urandom(32)
      pub = gost3410.public_key(CURVE, gost3410.prv_unmarshal(prv_raw))
      pub_raw = gost3410.pub_marshal(pub)
      print(json.dumps({
          "our": {"prv": hexenc(prv_raw), "pub": hexenc(pub_raw)},
          "their": {},
      }))
      exit(0)
  
  # Parse and unmarshal our and their keys {{{
  with open(args.keys, "rb") as fd:
      _keys = json.loads(fd.read().decode("utf-8"))
  KEY_OUR_SIGN_PRV = gost3410.prv_unmarshal(hexdec(_keys["our"]["prv"]))
  _pub = hexdec(_keys["our"]["pub"])
  KEY_OUR_SIGN_PUB = gost3410.pub_unmarshal(_pub)
  KEY_OUR_SIGN_PUB_HASH = OctetString(GOST34112012256(_pub).digest())
  for peer_name, pub_raw in _keys["their"].items():
      _pub = hexdec(pub_raw)
      KEYS[GOST34112012256(_pub).digest()] = {
          "name": peer_name,
          "pub": gost3410.pub_unmarshal(_pub),
      }
  # }}}
  

  GOST algoritmi privaatvõti on juhuslik number. Suurus on 256-bitine 256-bitiste elliptiliste kõverate jaoks. PyGOST töötab mitte baitide kogumiga, vaid suurte arvudega, seega peab meie privaatvõti (urandom(32)) olema muudetud numbriks, kasutades gost3410.prv_unmarshal(). Avalik võti arvutatakse deterministlikult privaatvõtme põhjal, kasutades gost3410.public_key(). Avalik võti 34.10 on kaks suurt arvu, mis tuleb samuti muudetud baitide järjestuseks, et neid oleks mugav hoida ja edastada, kasutades gost3410.pub_marshal().

  Pärast JSON-faili lugemist tuleb avalikud jaotised vastavalt tagasi muuta, kasutades gost3410.pub_unmarshal(). Kuna me saame vestluspartnerite identifikaatoreid avaliku võti häshtina, saab neid kohe ette arvutada ja paigutada sõnastikku kiireks otsimiseks. Stрибог-256 hash on gost34112012256.GOST34112012256(), mis vastab täielikult hashlib hash-funktsioonide liidesele.

  Kuidas algataja korutiin muutus? Kõik on nagu käepigistuse skeem: genereerime küpsise (128-bitti on täiesti piisav), ajutise võtme paari 34.10, mida kasutatakse VKO võtme kokkuleppe funktsioonis.

   395 async def initiator(host, port):
   396     _id = repr((host, port))
   397     logging.info("%s: dialing", _id)
   398     reader, writer = await asyncio.open_connection(host, port)
   399     # Generate our ephemeral public key and cookie, send Handshake 0 message {{{
   400     cookie_our = Cookie(urandom(16))
   401     prv = gost3410.prv_unmarshal(urandom(32))
   402     pub_our = gost3410.public_key(CURVE, prv)
   403     pub_our_raw = PubKey(gost3410.pub_marshal(pub_our))
   404     writer.write(Msg(("handshake0", MsgHandshake0((
   405         ("cookieInitiator", cookie_our),
   406         ("pubKeyInitiator", pub_our_raw),
   407     )))).encode())
   408     # }}}
   409     await writer.drain()
  

  • ootame vastust ja dekodeerime saabunud Msg sõnumi;
  • veendume, et saime handshake1;
  • dekodeerime vastaspoolse isepärase avaliku võtme ja arvutame seansi võtme;
  • loome sümpetrilised võtmed, mis on vajalikud TBE osa töötlemiseks.

   423     logging.info("%s: sai %s sõnum", _id, msg.choice)
   424     if msg.choice != "handshake1":
   425         logging.warning("%s: ootamatu sõnum, katkestamine", _id)
   426         writer.close()
   427         return
   428     # }}}
   429     msg_handshake1 = msg.value
   430     # Kinnita Handshake sõnum {{{
   431     cookie_their = msg_handshake1["cookieResponder"]
   432     pub_their_raw = msg_handshake1["pubKeyResponder"]
   433     pub_their = gost3410.pub_unmarshal(bytes(pub_their_raw))
   434     ukm_raw = bytes(msg_handshake1["ukm"])
   435     ukm = ukm_unmarshal(ukm_raw)
   436     key_session = kek_34102012256(CURVE, prv, pub_their, ukm, mode=2001)
   437     kdf = Hkdf(None, key_session, hash=GOST34112012256)
   438     key_handshake1_mac_identity = kdf.expand(b"handshake1-mac-identity")
   439     key_handshake1_enc = kdf.expand(b"handshake1-enc")
   440     key_handshake1_mac = kdf.expand(b"handshake1-mac")
  

  UKM on 64-bit number (urandom(8)), mis nõuab ka deserialiseerimist baitide esituses, kasutades gost3410_vko.ukm_unmarshal(). VKO funktsioon 34.10-2012 256-bit jaoks on gost3410_vko.kek_34102012256() (KEK — võtme krüpteerimise võti).

  Genereeritud sessioonivõti on juba 256-bitine juhuslik bitijada. Seetõttu saab seda kohe kasutada HKDF funktsioonis. Kuna GOST34112012256 vastab hashlib liidesele, saab seda kohe rakendada Hkdf klassis. Soola (esimene argument Hkdf) me ei määra, kuna genereeritud võti, arvestades osalevate võtmepaaride ajutisust, on iga sessiooni jaoks erinev ja see sisaldab piisavalt entropiat. kdf.expand() tagastab vaikimisi juba 256-bitiseid võtmeid, mis on vajalikud edasiseks Kузнечикule.

  Edasi kontrollitakse saabunud sõnumi TBE ja TBS osi:

  • arvutatakse ja kontrollitakse MAC saabunud ligipääsetud tekstile;
  • dešifreeritakse ligipääsetud tekst;
  • dekoodeeritakse TBE struktuur;
  • sealt võetakse vestluspartneri identifikaator ja kontrollitakse, kas see on meile teada;
  • arvutatakse ja kontrollitakse MAC selle identifikaatori üle;
  • kontrollitakse allkirja TBS struktuuri üle, kuhu kuuluvad mõlema poole küpsised ja avalik ajutine võti vastaspoolelt. Allkiri kontrollitakse vestluspartneri pikaajalise allkirja võtmega.

   441     try:
   442         peer_name = validate_tbe(
   443             msg_handshake1,
   444             key_handshake1_mac_identity,
   445             key_handshake1_enc,
   446             key_handshake1_mac,
   447             cookie_our,
   448             cookie_their,
   449             pub_their_raw,
   450         )
   451     except ValueError as err:
   452         logging.warning("%s: %s, disconnecting", _id, err)
   453         writer.close()
   454         return
   455     # }}}
  
   128 def validate_tbe(
   129         msg_handshake: Union[MsgHandshake1, MsgHandshake2],
   130         key_mac_identity: bytes,
   131         key_enc: bytes,
   132         key_mac: bytes,
   133         cookie_their: Cookie,
   134         cookie_our: Cookie,
   135         pub_key_our: PubKey,
   136 ) -> str:
   137     ciphertext = bytes(msg_handshake["ciphertext"])
   138     mac_tag = mac(GOST3412Kuznechik(key_mac).encrypt, KUZNECHIK_BLOCKSIZE, ciphertext)
   139     if not compare_digest(mac_tag, bytes(msg_handshake["ciphertextMac"])):
   140         raise ValueError("invalid MAC")
   141     plaintext = ctr(
   142         GOST3412Kuznechik(key_enc).encrypt,
   143         KUZNECHIK_BLOCKSIZE,
   144         ciphertext,
   145         8 * b"x00",
   146     )
   147     try:
   148         tbe, _ = HandshakeTBE().decode(plaintext)
   149     except ASN1Error:
   150         raise ValueError("can not decode TBE")
   151     key_sign_pub_hash = bytes(tbe["identity"])
   152     peer = KEYS.get(key_sign_pub_hash)
   153     if peer is None:
   154         raise ValueError("unknown identity")
   155     mac_tag = mac(
   156         GOST3412Kuznechik(key_mac_identity).encrypt,
   157         KUZNECHIK_BLOCKSIZE,
   158         key_sign_pub_hash,
   159     )
   160     if not compare_digest(mac_tag, bytes(tbe["identityMac"])):
   161         raise ValueError("invalid identity MAC")
   162     tbs = HandshakeTBS((
   163         ("cookieTheir", cookie_their),
   164         ("cookieOur", cookie_our),
   165         ("pubKeyOur", pub_key_our),
   166     ))
   167     if not gost3410.verify(
   168         CURVE,
   169         peer["pub"],
   170         GOST34112012256(tbs.encode()).digest(),
   171         bytes(tbe["signature"]),
   172     ):
   173         raise ValueError("invalid signature")
   174     return peer["name"]
  

  Nagu juba varem mainitud, kirjeldab 34.13-2015 erinevaid plokkšifrite töörežiime 34.12-2015. Nende seas on imitsükli genereerimise režiim, MAC-i arvutamine. PyGOST-is on see gost3413.mac(). See režiim nõuab šifreerimisfunktsiooni (mis võtab vastu ja tagastab ühe andmeploki), plokkšifri suurust ja tegelikke andmeid. Miks ei saa plokkšifri suurust kõvade koodidega määrata? 34.12-2015 kirjeldab mitte ainult 128-bitist Kurgi šifrit, vaid ka 64-bitist Magma – veidi muudetud ГОСТ 28147-89, mis loodi veel KGB poolt ja millel on endiselt üks kõrgeimaid turvalisuse piire.

  Kurgi initsialiseeritakse gost.3412.GOST3412Kuznechik(key) kutse kaudu ja tagastab objekti, millel on .encrypt()/ .decrypt() meetodid, mida saab edastada 34.13 funktsioonile. MAC arvutatakse järgmiselt: gost3413.mac(GOST3412Kuznechik(key).encrypt, KUZNECHIK_BLOCKSIZE, ciphertext). Arvutatud ja saadud MAC-i võrdlemiseks ei saa kasutada tavalist võrdlemist (==) baitide stringide vahel, kuna see toiming põhjustab ajavõrdsuse lekkeid, mis võib üldjuhul viia surmaga lõppevate haavatavusteni, nagu BEAST rünnakud TLS-i vastu. Pythonis on selle jaoks eriline hmac.compare_digest funktsioon.

  Plokkšifreerimise funktsioon suudab krüpteerida ainult ühe andmeploki. Suurema hulga, eriti mitte-korrutiste pikkusega andmete jaoks tuleb kasutada krüpteerimisrežiimi. 34.13-2015 kirjeldab järgmisi: ECB, CTR, OFB, CBC, CFB. Igal neist on oma lubatud kasutusvaldkonnad ja omadused. Kahjuks pole meil siiani standardiseeritud autentimisrežiime (nagu CCM, OCB, GCM ja sarnased) — oleme sunnitud vähemalt ise MAC lisama. Ma valin loenduri režiimi (CTR): see ei nõua ploki suurusele täiendamist, võib olla paralleelselt töötav, kasutab ainult krüpteerimisfunktsiooni ja seda saab ohutult kasutada suure hulga sõnumite krüpteerimiseks (erinevalt CBC-st, kus suhteliselt kiiresti hakkavad ilmuma kokkulangemised).

  Nagu .mac(), .ctr() võtab sarnaselt sisendina: ciphertext = gost3413.ctr(GOST3412Kuznechik(key).encrypt, KUZNECHIK_BLOCKSIZE, plaintext, iv). Nõutav on initsialiseerimissuuna määramine, mille pikkus on täpselt pool šifrisuurest. Kui meie krüpteerimisvõti kasutatakse ainult ühe sõnumi (isegi kui see sisaldab mitmeid blokke) krüpteerimiseks, siis on ohutu määrata null initsialiseerimissuund. Kätlemise sõnumite krüpteerimiseks kasutame iga kord eraldi võtit.

  Gost3410.verify() allkirja kontrollimine on triviaalne: edastame eliptilise kõveraga, mille piires töötame (selle fikseerime lihtsalt meie GOSTIM protokollis), allkirjastaja avaliku võtme (ärge unustage, et see peab olema kahe suure numbri paar, mitte baitide jada), 34.11-2012 rikke ja ise allkirja.

  Seejärel valmistame algatajas ette ja saadame handshake2 käepigistamise sõnumi, tehes samme sama, mida me tegime kontrollimisel, ainult sümmeetriliselt: allkiri oma võtmetega allkirjastamise asemel, jne...

   456     # Valmistage ja saatke Handshake 2 sõnum {{{
   457     tbs = HandshakeTBS((
   458         ("cookieTheir", cookie_their),
   459         ("cookieOur", cookie_our),
   460         ("pubKeyOur", pub_our_raw),
   461     ))
   462     signature = gost3410.sign(
   463         CURVE,
   464         KEY_OUR_SIGN_PRV,
   465         GOST34112012256(tbs.encode()).digest(),
   466     )
   467     key_handshake2_mac_identity = kdf.expand(b"handshake2-mac-identity")
   468     mac_tag = mac(
   469         GOST3412Kuznechik(key_handshake2_mac_identity).encrypt,
   470         KUZNECHIK_BLOCKSIZE,
   471         bytes(KEY_OUR_SIGN_PUB_HASH),
   472     )
   473     tbe = HandshakeTBE((
   474         ("identity", KEY_OUR_SIGN_PUB_HASH),
   475         ("signature", OctetString(signature)),
   476         ("identityMac", MAC(mac_tag)),
   477     ))
   478     tbe_raw = tbe.encode()
   479     key_handshake2_enc = kdf.expand(b"handshake2-enc")
   480     key_handshake2_mac = kdf.expand(b"handshake2-mac")
   481     ciphertext = ctr(
   482         GOST3412Kuznechik(key_handshake2_enc).encrypt,
   483         KUZNECHIK_BLOCKSIZE,
   484         tbe_raw,
   485         8 * b"x00",
   486     )
   487     mac_tag = mac(
   488         GOST3412Kuznechik(key_handshake2_mac).encrypt,
   489         KUZNECHIK_BLOCKSIZE,
   490         ciphertext,
   491     )
   492     writer.write(Msg(("handshake2", MsgHandshake2((
   493         ("ciphertext", OctetString(ciphertext)),
   494         ("ciphertextMac", MAC(mac_tag)),
   495     )))).encode())
   496     # }}}
   497     await writer.drain()
   498     logging.info("%s: sessioon on loodud: %s", _id, peer_name)
   

  Kui sessioon on loodud, genereeritakse transportvõtmed (eraldi võti krüpteerimiseks, tõendamiseks, kummagi osapoole jaoks), ja initsialiseeritakse Kuznechik dekrüpteerimiseks ja MAC-i kontrollimiseks:

   499     # Käivita tekstisõnumi saatja, initsialiseeri transport dekooder {{{
   500     key_initiator_enc = kdf.expand(b"transport-initiator-enc")
   501     key_initiator_mac = kdf.expand(b"transport-initiator-mac")
   502     key_responder_enc = kdf.expand(b"transport-responder-enc")
   503     key_responder_mac = kdf.expand(b"transport-responder-mac")
   ...
   509     asyncio.ensure_future(msg_sender(
   510         peer_name,
   511         key_initiator_enc,
   512         key_initiator_mac,
   513         writer,
   514     ))
   515     encrypter = GOST3412Kuznechik(key_responder_enc).encrypt
   516     macer = GOST3412Kuznechik(key_responder_mac).encrypt
   517     # }}}
   519     nonce_expected = 0
  
   520     # Oota test sõnumeid {{{
   521     while True:
   522         data = await reader.read(MaxMsgLen)
   ...
   530             msg, tail = Msg().decode(buf)
   ...
   537         try:
   538             await msg_receiver(
   539                 msg.value,
   540                 nonce_expected,
   541                 macer,
   542                 encrypter,
   543                 peer_name,
   544             )
   545         except ValueError as err:
   546             logging.warning("%s: %s", err)
   547             break
   548         nonce_expected += 1
   549     # }}}
  

  msg_sender korutina krüptib sõnumid enne nende saatmist TCP-ühendusse. Igal sõnumil on järjestikku kasvav nonce, mis on samuti initsialiseerimisvektor, kui krüpteerimine toimub loenduri režiimis. Igal sõnumil ja sõnumiplokil on garanteeritult erinevad loenduri väärtused.

  async def msg_sender(peer_name: str, key_enc: bytes, key_mac: bytes, writer) -> None:
      nonce = 0
      encrypter = GOST3412Kuznechik(key_enc).encrypt
      macer = GOST3412Kuznechik(key_mac).encrypt
      in_queue = IN_QUEUES[peer_name]
      while True:
          text = await in_queue.get()
          if text is None:
              break
          ciphertext = ctr(
              encrypter,
              KUZNECHIK_BLOCKSIZE,
              text.encode("utf-8"),
              long2bytes(nonce, 8),
          )
          payload = MsgTextPayload((
              ("nonce", Integer(nonce)),
              ("ciphertext", OctetString(ciphertext)),
          ))
          mac_tag = mac(macer, KUZNECHIK_BLOCKSIZE, payload.encode())
          writer.write(Msg(("text", MsgText((
              ("payload", payload),
              ("payloadMac", MAC(mac_tag)),
          )))).encode())
          nonce += 1
  

  Saabuvad sõnumid töötleb korutine msg_receiver, mis tegeleb autentimise ja dekrüpteerimisega:

  async def msg_receiver(
          msg_text: MsgText,
          nonce_expected: int,
          macer,
          encrypter,
          peer_name: str,
  ) -> None:
      payload = msg_text["payload"]
      if int(payload["nonce"]) != nonce_expected:
          raise ValueError("unexpected nonce value")
      mac_tag = mac(macer, KUZNECHIK_BLOCKSIZE, payload.encode())
      if not compare_digest(mac_tag, bytes(msg_text["payloadMac"])):
          raise ValueError("invalid MAC")
      plaintext = ctr(
          encrypter,
          KUZNECHIK_BLOCKSIZE,
          bytes(payload["ciphertext"]),
          long2bytes(nonce_expected, 8),
      )
      text = plaintext.decode("utf-8")
      await OUT_QUEUES[peer_name].put(text)
  

  Kokkuvõte

  GOSTIM on mõeldud kasutamiseks ainult hariduslikel eesmärkidel (kuna pole katsetustega kaetud, vähemalt)! Programmi lähtekoodi saab alla laadida siin (StriBog-256 hash: 995bbd368c04e50a481d138c5fa2e43ec7c89bc77743ba8dbabee1fde45de120). Nagu kõik mu projektid, on GoGOST, PyDERASN, NNCP, GoVPN, GOSTIM täiesti avamood, mida levitatakse GPLv3+.

  Sergei Matvejev, krüptopank, liige SPO Fondist, Python/Go arendaja, peaspetsialist FGUP „NTC Atlaas“.

Allikas: habr.com