GOSTIM: P2P F2F E2EE IM tráthnóna amháin le cripteagrafaíocht GOST

A bheith ina forbróir PyGOST leabharlanna (primitives cripteagrafacha GOST i Python íon), is minic a fhaigheann mé ceisteanna faoi conas na teachtaireachtaí slán is simplí a chur i bhfeidhm ar na glúine. Measann go leor daoine go bhfuil cripteagrafaíocht fheidhmeach simplí go leor, agus is leor glaoch a chur ar .encrypt() ar bhloc-siffr chun é a sheoladh go slán thar chainéal cumarsáide. Creideann daoine eile gurb é cripteagrafaíocht fheidhmeach cinniúint an bheagáin, agus tá sé inghlactha go bhfuil cuideachtaí saibhre cosúil le Telegram le matamaiticeoirí Oilimpeacha Ní féidir a chur i bhfeidhm prótacal slán.

Spreag sé seo go léir mé an t-alt seo a scríobh chun a thaispeáint nach tasc chomh deacair é prótacail cripteagrafacha agus IM slán a chur i bhfeidhm. Mar sin féin, ní fiú do phrótacail fíordheimhnithe agus eochair-chomhaontaithe féin a chumadh.

Beidh an t-alt ag scríobh piara-to-peer, cara le cara, ceann go deireadh criptithe teachtaire toirt le SIGMA-I prótacal fíordheimhnithe agus eochair-chomhaontaithe (ar a mbonn an IKE IPsec), ag baint úsáide as halgartaim chripteagrafach GOST go heisiach, leabharlann PyGOST agus leabharlann ionchódaithe teachtaireachta ASN.1 PyDERASN (faoi a bhfuil mé cheana féin scríobh roimh). Réamhriachtanas: caithfidh sé a bheith chomh simplí gur féidir é a scríobh ón tús in aon tráthnóna amháin (nó lá oibre), nó ní clár simplí é a thuilleadh. Is dócha go bhfuil earráidí ann, deacrachtaí gan ghá, easnaimh, agus is é seo mo chéad chlár ag baint úsáide as an leabharlann asyncio.

Dearadh IM

Ar dtús, ní mór dúinn a thuiscint cad a bheidh ar ár n-GS cosúil. Ar mhaithe le simplíocht, bíodh gur gréasán piara le piaraí é, gan teacht ar rannpháirtithe ar bith. Cuirfimid in iúl go pearsanta cén seoladh: calafort le nascadh leis chun cumarsáid a dhéanamh leis an idirghabhálaí.

Tuigim, ag an am seo, gur teorannú suntasach é an toimhde go bhfuil cumarsáid dhíreach ar fáil idir dhá ríomhaire treallach ar infheidhmeacht GS i gcleachtas. Ach dá mhéad forbróirí a chuireann gach cineál crutches trasnaithe NAT i bhfeidhm, is amhlaidh is faide a fhanfaimid ar an Idirlíon IPv4, agus is dócha go mbeidh cumarsáid idir ríomhairí treallach ann. Cé chomh fada is féidir leat an easpa IPv6 a fhulaingt sa bhaile agus ag an obair?

Beidh líonra cairde le cara againn: ní mór fios a bheith ag gach idirghabhálaí féideartha roimh ré. Ar an gcéad dul síos, déanann sé seo gach rud a shimpliú go mór: thugamar isteach muid féin, fuaireamar nó níor aimsigh an t-ainm/eochair, dínasctha nó lean ar aghaidh ag obair, agus an t-idirghabhálaí ar an eolas. Ar an dara dul síos, go ginearálta, tá sé slán agus cuireann sé deireadh le go leor ionsaithe.

Beidh an comhéadan IM gar do réitigh clasaiceacha tionscadail gan staonadh, rud a thaitníonn go mór liom as a gcuid minimalism agus fealsúnacht Unix-way. Cruthaíonn an clár IM eolaire le trí soicéad fearainn Unix do gach idirghabhálaí:

• i—Déantar teachtaireachtaí a sheoltar chuig an idirghabhálaí a thaifeadadh ann;
• amach - léitear teachtaireachtaí a fhaightear ón idirghabhálaí uaidh;
• luaigh - trí léamh uaidh, faighimid amach an bhfuil an t-idirghabhálaí ceangailte faoi láthair, an seoladh ceangail/port.

Ina theannta sin, cruthaítear soicéad conn, tríd an gcalafort óstach a scríobh isteach ina gcuirimid tús le nasc leis an gcian-idirghabhálaí.

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

Ligeann an cur chuige seo duit feidhmiú neamhspleách a dhéanamh ar iompar GS agus comhéadan úsáideora, toisc nach bhfuil aon chara ann, ní féidir leat gach duine a shásamh. Ag baint úsáide as tmux agus / nó multitail, is féidir leat comhéadan ilfhuinneog a fháil le béim ar chomhréir. Agus le cabhair rlwrap is féidir leat líne ionchuir teachtaireachta atá comhoiriúnach le GNU Readline a fháil.

Go deimhin, úsáideann tionscadail suckless comhaid FIFO. Go pearsanta, ní raibh mé in ann a thuiscint conas a bheith ag obair le comhaid iomaíoch in asyncio gan cúlra lámhscríofa ó snáitheanna tiomnaithe (Tá mé ag baint úsáide as an teanga le haghaidh a leithéid de rudaí le fada an lá Go). Mar sin, chinn mé déanamh le soicéid fearainn Unix. Ar an drochuair, fágann sé seo go bhfuil sé dodhéanta macalla a dhéanamh 2001:470:marbh::babe 6666 > conn. Réitigh mé an fhadhb seo ag baint úsáide as socat: macalla 2001:470:marbh::babe 6666 | socat - UNIX-CONNECT:conn, socat LÉIGHINN UNIX-CONNECT:alice/in.

An prótacal neamhdhaingean bunaidh

Úsáidtear TCP mar iompar: ráthaíonn sé seachadadh agus a ordú. Ní ráthaíonn UDP ceachtar acu (rud a bheadh ​​úsáideach nuair a úsáidtear cripteagrafaíocht), ach tacaíocht SCTP Ní thagann Python as an mbosca.

Ar an drochuair, i TCP níl aon choincheap de theachtaireacht, ach sruth beart. Mar sin, is gá teacht suas le formáid do theachtaireachtaí ionas gur féidir iad a roinnt eatarthu féin sa snáithe seo. Is féidir linn aontú an carachtar beatha líne a úsáid. Tá sé ceart go leor do thosaitheoirí, ach a luaithe a thosaímid ag criptiú ár dteachtaireachtaí, féadfaidh an carachtar seo a bheith le feiceáil áit ar bith sa ciphertext. I líonraí, mar sin, is iad na prótacail mhóréilimh iad siúd a sheolann fad na teachtaireachta i mbearta den chéad uair. Mar shampla, as an mbosca tá xdrlib ag Python, a ligeann duit oibriú le formáid den chineál céanna XDR.

Ní oibreoimid i gceart agus go héifeachtach le léamh TCP - déanfaimid an cód a shimpliú. Léimid sonraí ón soicéad i lúb gan teorainn go dtí go ndéanaimid an teachtaireacht iomlán a dhíchódú. Is féidir JSON le XML a úsáid mar fhormáid don chur chuige seo freisin. Ach nuair a chuirtear cripteagrafaíocht leis, ní mór na sonraí a shíniú agus a fhíordheimhniú - agus beidh gá le léiriú comhionann beart-ar-beart ar oibiachtaí, rud nach soláthraíonn JSON/XML (d’fhéadfadh go mbeadh éagsúlacht ag baint le torthaí dumpaí).

Tá XDR oiriúnach don tasc seo, ach roghnaíonn mé ASN.1 le ionchódú DER agus PyDERASN leabharlann, toisc go mbeidh rudaí ardleibhéil idir lámha againn a mbíonn sé níos taitneamhaí agus níos áisiúla oibriú leo go minic. Murab ionann agus schemaless bencode, MessagePack nó CBOR, seiceálfaidh ASN.1 na sonraí go huathoibríoch i gcoinne scéimre códaithe crua.

# 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))),
    ))

Msg a bheidh sa teachtaireacht a gheofar: téacs MsgText (le réimse téacs amháin faoi láthair) nó teachtaireacht chroitheadh ​​láimhe MsgHandshake (ina bhfuil ainm an idirghabhálaí). Anois tá cuma ró-chasta air, ach is bunús é seo don todhchaí.

     ┌─────┐ ┌─────┐ │ PeerA│ │PeerB│ └──┬───└──┘ └────── ) │ │──────── ─ ────────>│ │ │ │ │ Croitheadh ​​Láimhe(IdB) │ │<──────── ─── │ │ MsgText() │ │─── ─ MsgText() │ │ │

IM gan cripteagrafaíocht

Mar a dúirt mé cheana, úsáidfear an leabharlann asyncio do gach oibríocht soicéad. Déanaimis a bhfuil súil againn a fhógairt ag an seoladh:

parser = argparse.ArgumentParser(description="GOSTIM")
parser.add_argument(
    "--our-name",
    required=True,
    help="Our peer name",
)
parser.add_argument(
    "--their-names",
    required=True,
    help="Their peer names, comma-separated",
)
parser.add_argument(
    "--bind",
    default="::1",
    help="Address to listen on",
)
parser.add_argument(
    "--port",
    type=int,
    default=6666,
    help="Port to listen on",
)
args = parser.parse_args()
OUR_NAME = UTF8String(args.our_name)
THEIR_NAMES = set(args.their_names.split(","))

Socraigh d'ainm féin (--ár n-ainm alice). Tá na hidirghabhálaithe go léir a bhfuiltear ag súil leo liostaithe scartha le camóga ( —a n-ainmneacha bob, oíche). I gcás gach ceann de na hidirghabhálaithe, cruthaítear eolaire le soicéid Unix, chomh maith le coroutine do gach duine isteach, amach, luaigh:

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"))

Seoltar teachtaireachtaí a thagann ón úsáideoir ón soicéad isteach chuig an scuaine IN_QUEUES:

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"))

Seoltar teachtaireachtaí a thagann ó idirghabhálaithe chuig scuainí OUT_QUEUES, óna scríobhtar sonraí chuig an soicéad amach:

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()

Agus tú ag léamh ó shoicéad stáit, lorgaíonn an clár seoladh an idirghabhálaí san fhoclóir PEER_ALIVE. Mura bhfuil aon nasc leis an idirghabhálaí fós, scríobhtar líne fholamh.

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()

Agus seoladh á scríobh chuig soicéad conn, seoltar an fheidhm “tionscnóir” naisc:

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))

Déanaimis machnamh ar an tionscnóir. Ar dtús is léir go n-osclaíonn sé nasc leis an ósta/port sonraithe agus seolann sé teachtaireacht chroitheadh ​​láimhe darb ainm:

 130 async def initiator(host, port):
 131     _id = repr((host, port))
 132     logging.info("%s: dialing", _id)
 133     reader, writer = await asyncio.open_connection(host, port)
 134     # Handshake message {{{
 135     writer.write(Msg(("handshake", MsgHandshake((
 136         ("peerName", OUR_NAME),
 137     )))).encode())
 138     # }}}
 139     await writer.drain()

Ansin, fanann sé ar fhreagra ón gcóisir iargúlta. Déanann sé iarracht an freagra isteach a dhíchódú trí úsáid a bhaint as scéim Msg ASN.1. Glacaimid leis go seolfar an teachtaireacht ar fad i mír TCP amháin agus go bhfaighfimid go adamhach é nuair a ghlaoimid ar .read(). Déanaimid seiceáil go bhfuaireamar an teachtaireacht chroitheadh ​​láimhe.

 141     # Wait for Handshake message {{{
 142     data = await reader.read(256)
 143     if data == b"":
 144         logging.warning("%s: no answer, disconnecting", _id)
 145         writer.close()
 146         return
 147     try:
 148         msg, _ = Msg().decode(data)
 149     except ASN1Error:
 150         logging.warning("%s: undecodable answer, disconnecting", _id)
 151         writer.close()
 152         return
 153     logging.info("%s: got %s message", _id, msg.choice)
 154     if msg.choice != "handshake":
 155         logging.warning("%s: unexpected message, disconnecting", _id)
 156         writer.close()
 157         return
 158     # }}}

Déanaimid seiceáil go bhfuil ainm faighte an idirghabhálaí ar eolas againn. Mura bhfuil, ansin briseann muid an nasc. Déanaimid seiceáil an bhfuil nasc bunaithe againn cheana féin leis (thug an t-idirghabhálaí an t-ordú arís chun ceangal a dhéanamh linn) agus é a dhúnadh. Coinníonn an scuaine IN_QUEUES teaghráin Python le téacs na teachtaireachta, ach tá luach ar leith ag None a thugann comhartha don choroutine msg_sender stop a bheith ag obair ionas go ndéanann sé dearmad ar a scríbhneoir a bhaineann leis an nasc oidhreachta TCP.

 159     msg_handshake = msg.value
 160     peer_name = str(msg_handshake["peerName"])
 161     if peer_name not in THEIR_NAMES:
 162         logging.warning("unknown peer name: %s", peer_name)
 163         writer.close()
 164         return
 165     logging.info("%s: session established: %s", _id, peer_name)
 166     # Run text message sender, initialize transport decoder {{{
 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     # }}}

glacann msg_sender le teachtaireachtaí amach (ciúáilte ó shoicéad isteach), cuireann sé iad i dteachtaireacht MsgText agus seolann sé thar nasc TCP iad. Is féidir é a bhriseadh tráth ar bith - táimid idircheapadh go soiléir seo.

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))

Ag an deireadh, cuireann an tionscnóir lúb gan teorainn de teachtaireachtaí léitheoireachta ón soicéad. Seiceálann cibé acu an teachtaireachtaí téacs iad na teachtaireachtaí seo agus cuireann sé sa scuaine OUT_QUEUES iad, óna seolfar chuig soicéad amach an idirghabhálaí chomhfhreagraigh iad. Cén fáth nach féidir leat ach .read() a dhéanamh agus an teachtaireacht a dhíchódú? Toisc gur féidir go ndéanfar roinnt teachtaireachtaí ón úsáideoir a chomhiomlánú i maolán an chórais oibriúcháin agus iad a sheoladh in aon mhír TCP amháin. Is féidir linn an chéad cheann a dhíchódú, agus ansin féadfaidh cuid den cheann ina dhiaidh sin fanacht sa mhaolán. I gcás aon chor neamhghnách, dúnaimid an nasc TCP agus stopaimid an coroutine msg_sender (trí None a sheoladh chuig an scuaine OUT_QUEUES).

 174     buf = b""
 175     # Wait for test messages {{{
 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: max buffer size exceeded", _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: unexpected %s message", _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: disconnecting: %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: received %d characters message", peer_name, len(text))
  69     await OUT_QUEUES[peer_name].put(text)

Fillfimid ar an bpríomhchód. Tar éis na coroutines go léir a chruthú ag an am a thosaíonn an clár, cuirimid tús leis an bhfreastalaí TCP. I gcás gach nasc bunaithe, cruthaíonn sé coroutine freagróra.

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("Listening on: %s", server.sockets[0].getsockname())
loop.run_forever()

Tá an freagróir cosúil leis an tionscnóir agus léiríonn sé na gníomhartha céanna go léir, ach tosaíonn lúb gan teorainn na dteachtaireachtaí léitheoireachta láithreach, ar mhaithe le simplíocht. Faoi láthair, cuireann an prótacal croitheadh ​​láimhe teachtaireacht amháin ó gach taobh, ach sa todhchaí beidh dhá cheann ón tionscnóir nasc, agus ina dhiaidh sin is féidir teachtaireachtaí téacs a sheoladh láithreach.

  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()

Prótacal slán

Tá sé in am againn ár gcumarsáid a dhaingniú. Cad atá i gceist againn le slándáil agus cad atá uainn:

• rúndacht na dteachtaireachtaí tarchurtha;
• barántúlacht agus sláine na dteachtaireachtaí tarchurtha - ní mór a n-athruithe a bhrath;
• cosaint i gcoinne ionsaithe athimeartha - ní mór teachtaireachtaí ar iarraidh nó arís agus arís eile a bhrath (agus socraímid deireadh a chur leis an nasc);
• aithint agus fíordheimhniú idirghabhálaithe ag baint úsáide as eochracha poiblí réamhiontráilte - shocraigh muid cheana féin go raibh muid ag déanamh líonra cara le cara. Is tar éis fíordheimhnithe amháin a thuigfimid cé leis a bhfuilimid i mbun cumarsáide;
• infhaighteacht rúndacht tosaigh foirfe réadmhaoin (PFS) - níor cheart go mbeifí in ann gach comhfhreagras roimhe seo a léamh má chuirtear ár n-eochair sínithe fadchónaithe i mbaol. Ní dhéanfaidh aon mhaith trácht a thaifeadadh;
• bailíocht/bailíocht teachtaireachtaí (iompar agus croitheadh ​​láimhe) laistigh de sheisiún TCP amháin. Níor cheart go mbeadh sé indéanta teachtaireachtaí sínithe/fíordheimhnithe i gceart ó sheisiún eile a chur isteach (fiú leis an idirghabhálaí céanna);
• níor cheart do bhreathnadóir éighníomhach aitheantóirí úsáideora, eochracha poiblí fadsaoil a tharchur, nó hashes uathu a fheiceáil. Ainm áirithe ó bhreathnadóir éighníomhach.

Is ábhar iontais é gur mian le beagnach gach duine an t-íosmhéid seo a bheith acu in aon phrótacal croitheadh ​​láimhe, agus is beag an méid thuas a chomhlíontar i ndeireadh na dála le haghaidh prótacail “dúchais”. Anois ní dhéanfaimid aon rud nua a chumadh. Ba mhaith liom a mholadh cinnte a úsáid Creat torainn le haghaidh prótacail a thógáil, ach déanaimis rud éigin níos simplí a roghnú.

Is iad an dá phrótacal is coitianta ná:

• TLS - prótacal an-chasta le stair fhada de fhabhtanna, subha, leochaileachtaí, droch-mhachnamh, castacht agus easnaimh (ach is beag an bhaint atá aige seo le TLS 1.3). Ach ní mheasaimid é toisc go bhfuil sé ró-chasta.
• IPsec с IKE - nach bhfuil fadhbanna cripteagrafacha tromchúiseacha acu, cé nach bhfuil siad simplí freisin. Má léann tú faoi IKEv1 agus IKEv2, is é an fhoinse atá acu STSPrótacail , ISO/IEC IS 9798-3 agus SIGMA (SIGn-agus-MAc) - simplí go leor le cur i bhfeidhm tráthnóna amháin.

Cad atá go maith faoi SIGMA, mar an nasc is déanaí i bhforbairt prótacail STS/ISO? Comhlíonann sé ár gcuid riachtanas go léir (lena n-áirítear aitheantóirí idirghabhálaí a “bhfolú”) agus níl aon fhadhbanna cripteagrafacha aitheanta aige. Tá sé íostach - má bhaintear eilimint amháin ar a laghad as an teachtaireacht prótacail beidh sé ina chúis le neamhshlándáil.

Rachaimid ón bprótacal baile is simplí go SIGMA. Is é an oibríocht is bunúsaí a bhfuil suim againn ann comhaontú eochair: Feidhm a aschuireann an dá rannpháirtí an luach céanna, ar féidir é a úsáid mar eochair shiméadrach. Gan dul isteach i sonraí: gineann gach ceann de na páirtithe péire ephemeral (a úsáidtear ach amháin laistigh de seisiún amháin) eochair (eochracha poiblí agus príobháideacha), a mhalartú eochracha poiblí, glaoch ar an fheidhm comhaontaithe, chun an t-ionchur a théann siad a n-eochair phríobháideach agus an phobail. eochair an idirghabhálaí.

┌─────┐ ┌─────┐ │ PeerA│ │PeerB│ └─────┘ └────── │ ╔══════════ ══════════╗ │──────────────>│ ║(PrvA, PrvA) ─ ─ ════════ ═══════════╝ │ IdB, PubB │ ╔════════════␕␕␂ ───────── ──────│ ║PrvB, PubB = DHgen() ║ │ │ ╚═════════════␕― ─ ──┐ ╔════ ═══╧════════════╗ │ ║ Eochair = DH(PrvA, PubB)║ <───┘ ␕╕ ═══════ ════╝ │ │ │ │

Is féidir le duine ar bith léim sa lár agus a gcuid eochracha poiblí féin a athsholáthar - níl aon fhíordheimhniú idirghabhálaithe sa phrótacal seo. Cuirimis síniú le heochracha fadsaoil leis.

┌─────┐ ┌─────┐ │ PeerA│ │PeerB│ └──┬──┘ └──┘ ─── SignPrvA, (PubA)) │ ╔═ Cláraigh A = ualach() ║ │ │ ║ PrvA, PubA = DHgen() ║ │ │ ╚════════ ══════ ════════════␂ ═, comhartha (SignPrvB, (PubB)) │ ╔═══════════════ ══════ ══════════ ══════ ════― ‗ ────────── ────────────── ─│ ║ SignPrvB, SignPubB = ualach( )║ │ │ ║ PrvB, PubB │ ║ │ │ ║ PrvB, PubB = ║ ═════════ ═══════════════ ═╝ ────┐ ╔ ══════␕║ ═════╗ │ │ ║fíoraigh( SignPubB, ...) ║ │ <───┘ ║ Eochair = DH(PrvA , PubB) ║ │ │ ╚══════════════ ═ ═╝ │ │ │

Ní oibreoidh síniú den sórt sin, ós rud é nach bhfuil sé ceangailte le seisiún ar leith. Tá teachtaireachtaí dá leithéid “oiriúnach” freisin do sheisiúin le rannpháirtithe eile. Ní mór don chomhthéacs iomlán síntiús a íoc. Cuireann sé seo iallach orainn teachtaireacht eile ó A a chur leis freisin.

Ina theannta sin, tá sé ríthábhachtach d'aitheantóir féin a chur leis faoin síniú, mar ar shlí eile is féidir linn IdXXX a ionadú agus an teachtaireacht a athshíniú le heochair idirghabhálaí aitheanta eile. Chun cosc ​​a chur ionsaithe machnaimh, is gá go mbeadh na heilimintí faoin síniú in áiteanna atá sainmhínithe go soiléir de réir a gciall: má chomharthaíonn A (PubA, PubB), ansin caithfidh B síniú (PubB, PubA). Labhraíonn sé seo freisin ar a thábhachtaí atá sé struchtúr agus formáid na sonraí sraitheach a roghnú. Mar shampla, déantar tacair in ionchódú ASN.1 DER a shórtáil: beidh SET OF(PubA, PubB) comhionann le SET OF(PubB, PubA).

┌─────┐ ┌─────┐ │ PeerA│ │PeerB│ └─────┘ └────── │ ╔══════════ ═════════════════╗ │───────────——————————─ ────────── ─────────────>│ ║ SignPrvA, SignPubA = ualach()║ │ │ ║ PrvA, PubA = DHgen() ║ ║ ─ ═ ══════ ═══════════════╝ │IdB, PubB, comhartha(ComharthaPrvB, (IdB, PubA, PubB)) │ ═ ␕ ╕ ═════ ════════════╗ │<─────────────────────── ───────── ─────────│ ║ SignPrvB, SignPubB = ualach() ║ │ │ ║ PrvB, PubB = DHgen() ║ │ ┐ ╚ │ │ ␕ │ ═ ═══════ ══════════╝ │ comhartha(SignPrvA, (IDA, PubB, PubA)) │ ╔═══════ ═ ═══␐══ ═══╗│─ ────────────────────────────────────────── ──>│ ║fíoraigh(SignPubB, ...) ║ │ │ ║Eochair = DH(PrvA, PubB) ║ │ │ ╚═══════════════␕ ═══ ␂

Mar sin féin, níl "cruthú" fós againn go bhfuil an eochair chomhroinnte chéanna ginte againn don seisiún seo. I bprionsabal, is féidir linn a dhéanamh gan an chéim seo - beidh an chéad nasc iompair neamhbhailí, ach ba mhaith linn nuair a bheidh an croitheadh ​​láimhe críochnaithe, ba mhaith linn a bheith cinnte go bhfuil gach rud aontaithe i ndáiríre. Faoi láthair tá an prótacal ISO/IEC IS 9798-3 idir lámha againn.

D’fhéadfaimis an eochair ghinte féin a shíniú. Tá sé seo contúirteach, ós rud é go bhféadfadh sceitheadh ​​a bheith ann san algartam sínithe a úsáidtear (cé go giotán in aghaidh an tsínithe, ach fós sceitheanna). Is féidir hash den eochair díorthaithe a shíniú, ach d’fhéadfadh sé a bheith luachmhar má sceitheadh ​​fiú hash na heochrach díorthaithe in ionsaí brúidiúil ar an bhfeidhm díorthaithe. Úsáideann SIGMA feidhm MAC a fhíordheimhníonn aitheantas an tseoltóra.

┌─────┐ ┌─────┐ │ PeerA│ │PeerB│ └─────┘ └────── │ ╔══════════ ═════════════════╗ │───────────——————————─ ────────── ──────────────────>│ ║ SignPrvA, SignPubA = ualach() ║ │ │ ⚕ Prv = A │ │ ⚕ Prv │ ═ ══════ ═══════════════ ═════╝ │IdB, PubB, comhartha(SignPrvB, (PubA, PubB) ╔) ═══ ════════════════════╗│<────────——————————─ ───────── ─────────────────────│ ║ SignPrvB, SignPubB = ualach() ║ │ │ │ B │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ╚════ ═ ══════════════════════╝ │ ╔═════════║ comhartha ════════╗ │ comhartha (ComharthaPrvA, (PubB, PubA)), MAC(IDA) │ ║Eochair = DH(PrvA, PubB) ║ │ ─────────────—————————————————————————— ─ ─ ─────────────────────────>│ ───────────────────>│ ║fíoraigh(Eochair, IdB) │ │ │ │ │ │ │ │ ║ │ │ ╚ ═════════════════════╝ │ │

Mar leas iomlán a bhaint, b'fhéidir gur mhaith le cuid acu a n-eochracha gearrshaolacha a athúsáid (rud atá, ar ndóigh, trua do PFS). Mar shampla, ghin muid eochairphéire, rinneamar iarracht nascadh, ach ní raibh TCP ar fáil nó cuireadh isteach air áit éigin i lár an phrótacail. Is mór an náire acmhainní eantrópachta agus próiseálaithe a chur amú ar phéire nua. Mar sin, tabharfaimid isteach an fianán mar a thugtar air - luach bréagach randamach a chosnóidh i gcoinne ionsaithe athimeartha randamacha a d'fhéadfadh a bheith ann agus eochracha poiblí gearrthéarmacha á n-athúsáid. Mar gheall ar an gceangal idir an fianán agus an eochair phoiblí ghearrshaolach, is féidir eochair phoiblí an pháirtí eile a bhaint den síniú mar rud nach gá.

┌─────┐ ┌─────┐ │PeerA│ │PeerB│ └─────────┘ └──┘ └─── A │ ╔════════ ═══════════════════╗ │──────────——————————─ ────────── ────────────────────────────────────────── >│ ║SignPrvA, SignPubA = ualach( )║ │ │ ║ PrvA, PubA = DHgen() ║ │ │ ╚═══════════════␐═══␕ ═ ═╝ │IdB, PubB, CookieB , comhartha(SignPrvB, (CookieA, CookieB, PubB)), MAC(IdB) │ ╔═════════════════␕␕␕␕␕ ╗ │< ────────────────────────────────────────── ───────── ────────────────────│ ║ SignPrvB, SignPubB = ualach() ║ │ │ │ B │ │ │ B │ │ │ B │ │ B │ │ │ B │ │ │ B │ │ ╚══════ ═════════════════════╝ │ │ ╔══════════║ comhartha ══════╗ │ comhartha( SignPrvA, (FianánB, FianánA, PubA)), MAC(IdA) │ ║ Eochair = DH(PrvA, PubB) ║ │────────────————————————————————————————————————————————————─ ─ ────────────────────────────────────────── ──────>│ ║ fíoraigh(Eochair, IdB) ║ │ │ ║fíoraigh(SignPubB,...) ║ │ │ ╚══════════════␕␕␕ │

Ar deireadh, ba mhaith linn príobháideacht ár gcomhpháirtithe comhrá a fháil ó bhreathnadóir éighníomhach. Chun seo a dhéanamh, tá sé beartaithe ag SIGMA eochracha gearrshaolacha a mhalartú ar dtús agus eochair choiteann a fhorbairt ar a bhféadfaí fíordheimhniú agus aithint teachtaireachtaí a chriptiú. Déanann SIGMA cur síos ar dhá rogha:

• SIGMA-I - cosnaíonn sé an tionscnóir ó ionsaithe gníomhacha, an freagróir ó ionsaithe éighníomhacha: fíordheimhníonn an tionscnóir an freagróir agus mura n-oireann rud éigin, ní thugann sé aitheantas dó. Tugann an cosantóir a aitheantas má chuirtear tús le prótacal gníomhach leis. Ní fhoghlaimíonn an breathnóir éighníomhach rud ar bith;
  SIGMA-R - a chosnaíonn an freagróir ó ionsaithe gníomhacha, an tionscnóir ó na cinn éighníomhacha. Tá gach rud díreach ina coinne, ach sa phrótacal seo tá ceithre theachtaireacht chroitheadh ​​láimhe tarchurtha cheana féin.

  Roghnaimid SIGMA-I mar go bhfuil sé níos cosúla leis an méid a bhfuil súil againn ó rudaí eolach cliant-freastalaí: is é an freastalaí fíordheimhnithe amháin a aithnítear an cliant, agus tá a fhios ag gach duine ar an bhfreastalaí cheana féin. Ina theannta sin tá sé níos éasca é a chur i bhfeidhm mar gheall ar níos lú teachtaireachtaí croith láimhe. Is é an t-aon rud a chuirimid leis an bprótacal ná cuid den teachtaireacht a chriptiú agus an t-aitheantóir A a aistriú go dtí an chuid criptithe den teachtaireacht dheireanach:

  ┌─────┐ ┌─────┐ │PeerA│ │PeerB│ └──┬──┘ └── ─ ─ ── │ ╔══════════ ═════════════════╗ │───────────——————————─ ────────── ────────────────────────────────────────── ─────>│ ║ SignPrvA , SignPubA = ualach() ║ │ │ ║ PrvA, PubA = DHgen() ║ │ │ ╚═══════════════════════ ════╝ │ PubB, FianánB, Enc((IdB, comhartha(SignPrvB, (CookieA, CookieB, PubB)), MAC(IdB)))) │ ╔ ═ ══ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═ ␕ ═ ═ ═ ␕ ═ ═══════╗│<─────────────────────────—── ───────── ║SignPrv B, SignPubB = ualach()║ │ │ ║ PrvB, PubB = DHgen() ║ │ │ ╚═════════␐═ ═══════ ═╝ │ │ ╔ ════════ ═════════════╗ │ Enc(Avie, Cook, Sign(Avie), Enc(Avie,Cook) MAC(IDA) )) │ ║Eochair = DH(PrvA, PubB) ║ │────────────────────────── ────── ──── ───────── ──────────────────────────── ─>│ ║fíoraigh(Eochair, IdB) ║ │ │ ║fíoraigh(Cláraigh Tábhairne,...)║ │ │ ╚═════════════════␂
  

  • Úsáidtear GOST R le haghaidh síniú 34.10-2012 algartam le heochracha 256-giotán.
  • Chun an eochair phoiblí a ghiniúint, úsáidtear 34.10/2012/XNUMX VKO.
  • Úsáidtear CMAC mar an MAC. Go teicniúil, is modh oibríochta speisialta é seo de bhloc-sipher, a thuairiscítear i GOST R 34.13-2015. Mar fheidhm criptithe don mhód seo - Dreoilín teaspaigh (34.12-2015).
  • Úsáidtear hash a eochair phoiblí mar aitheantóir an idirghabhálaí. Úsáidte mar hash Streachailt-256 (34.11/2012/256 XNUMX giotán).

  Tar éis an chroitheadh ​​láimhe, comhaontóidh muid ar eochair roinnte. Is féidir linn é a úsáid chun teachtaireachtaí iompair a chriptiú fíordheimhnithe. Tá an chuid seo an-simplí agus deacair botún a dhéanamh: déanaimid an cuntar teachtaireachta a incrimint, an teachtaireacht a chriptiú, an cuntar agus an ciphertext a fhíordheimhniú (MAC), seol. Nuair a fhaigheann muid teachtaireacht, déanaimid seiceáil go bhfuil an luach ionchais ag an gcuntar, fíordheimhnigh an ciphertext leis an gcuntar, agus díchriptigh é. Cén eochair ba cheart dom a úsáid chun teachtaireachtaí croitheadh ​​láimhe a chriptiú, teachtaireachtaí a iompar, agus conas iad a fhíordheimhniú? Tá sé contúirteach agus mí-chiallmhar úsáid a bhaint as eochair amháin do na tascanna seo go léir. Is gá eochracha a ghiniúint ag baint úsáide as feidhmeanna speisialaithe KDF (feidhm díorthaithe eochair). Arís, ná scoiltimis ribí agus déanaimis rud éigin: HKDF le fada an lá, taighde maith agus níl aon fadhbanna aitheanta. Ar an drochuair, níl an fheidhm seo ag leabharlann dúchais Python, mar sin úsáidimid hkdf mála plaisteach. Úsáideann HKDF go hinmheánach HMAC, a úsáideann feidhm hash ar a seal. Ní thógann sé ach cúpla líne cód mar shampla forfheidhmiú i Python ar an leathanach Vicipéid. Mar a tharla i gcás 34.10/2012/256, úsáidfimid Stribog-XNUMX mar fheidhm hash. Tabharfar an eochair seisiúin ar aschur ár bpríomhfheidhm comhaontaithe, óna nginfear na cinn siméadracha atá in easnamh:

  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")
  

  Struchtúir/Scéimeanna

  Breathnaímid ar na struchtúir ASN.1 atá againn anois chun na sonraí seo go léir a tharchur:

  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)
  

  Is é HandshakeTBS an rud a shíneofar. HandshakeTBE - cad a bheidh criptithe. Dírím d’aird ar an réimse ukm in MsgHandshake1. 34.10 Áirítear VKO, le haghaidh randamachú níos mó fós ar na heochracha ginte, paraiméadar UKM (ábhar eochrach úsáideora) - gan ach eantrópacht bhreise.

  Cripteagrafaíocht a Chur leis an gCód

  Déanaimis machnamh ach ar na hathruithe a rinneadh ar an gcód bunaidh, ós rud é gur fhan an creat mar an gcéanna (go deimhin, scríobhadh an cur i bhfeidhm deiridh ar dtús, agus ansin gearradh an cripteagrafaíocht go léir as).

  Ós rud é go ndéanfar fíordheimhniú agus sainaithint idirghabhálaithe ag baint úsáide as eochracha poiblí, ní mór iad a stóráil anois in áit éigin ar feadh i bhfad. Ar mhaithe le simplíocht, úsáidimid JSON mar seo:

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

  ár - ár bpéire eochair, eochracha heicsidheacha, príobháideacha agus poiblí. — ainmneacha na n-idirghabhálaithe agus a n-eochracha poiblí. Athraímis na hargóintí líne ordaithe agus cuirimis iarphróiseáil sonraí JSON leis:

  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="Generate JSON with our new keypair",
  )
  parser.add_argument(
      "--keys",
      default="keys.json",
      required=False,
      help="JSON with our and their keys",
  )
  parser.add_argument(
      "--bind",
      default="::1",
      help="Address to listen on",
  )
  parser.add_argument(
      "--port",
      type=int,
      default=6666,
      help="Port to listen on",
  )
  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),
      }
  # }}}
  

  Is uimhir randamach í eochair phríobháideach an algartam 34.10. Méid 256-giotán le haghaidh cuair éilipseacha 256-giotán. Ní oibríonn PyGOST le sraith beart, ach le líon mór, mar sin ní mór ár n-eochair phríobháideach (urandom(32)) a thiontú go huimhir ag baint úsáide as gost3410.prv_unmarshal(). Cinntear an eochair phoiblí go cinntitheach ón eochair phríobháideach ag baint úsáide as gost3410.public_key(). Is é atá san eochair phoiblí 34.10 ná dhá uimhir mhóra ar gá iad a thiontú ina seicheamh beart freisin ar mhaithe le héascaíocht stórála agus tarchurtha ag baint úsáide as gost3410.pub_marshal().

  Tar éis an comhad JSON a léamh, ní mór na heochracha poiblí a thiontú ar ais dá réir sin trí úsáid a bhaint as gost3410.pub_unmarshal(). Ós rud é go bhfaighfimid aitheantóirí na n-idirghabhálaithe i bhfoirm hash ón eochair phoiblí, is féidir iad a ríomh láithreach roimh ré agus a chur i bhfoclóir le haghaidh cuardach tapa. Tá hash Stribog-256 gost34112012256.GOST34112012256(), a shásaíonn go hiomlán comhéadan hashlib na bhfeidhmeanna hash.

  Conas a d'athraigh coroutine an tionscnóra? Tá gach rud de réir na scéime croith láimhe: gineann muid fianán (tá 128-giotán go leor), péire eochair gearrshaolach 34.10, a úsáidfear le haghaidh feidhm chomhaontaithe eochair VKO.

   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()
  

  • táimid ag fanacht le freagra agus díchódaithe an teachtaireacht Msg isteach;
  • déan cinnte go bhfaigheann tú croitheadh ​​láimhe1;
  • eochair phoiblí ghearrshaolach an pháirtí eile a dhíchódú agus eochair an tseisiúin a ríomh;
  • Gineann muid eochracha siméadracha atá riachtanach chun an chuid TBE den teachtaireacht a phróiseáil.

   423     logging.info("%s: got %s message", _id, msg.choice)
   424     if msg.choice != "handshake1":
   425         logging.warning("%s: unexpected message, disconnecting", _id)
   426         writer.close()
   427         return
   428     # }}}
   429     msg_handshake1 = msg.value
   430     # Validate Handshake message {{{
   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")
  

  Is uimhir 64-giotán í UKM (urandom(8)), a éilíonn freisin díshraithiú óna léiriú beart ag baint úsáide as gost3410_vko.ukm_unmarshal(). Is é feidhm VKO le haghaidh 34.10/2012/256 3410-giotán ná gost34102012256_vko.kek_XNUMX() (KEK - eochair criptithe).

  Is seicheamh beart randamach randamach 256-giotán an eochair seisiúin a ghintear cheana féin. Mar sin, is féidir é a úsáid láithreach i bhfeidhmeanna HKDF. Ós rud é go sásaíonn GOST34112012256 an comhéadan hashlib, is féidir é a úsáid láithreach sa rang Hkdf. Ní shonraíonn muid an salann (an chéad argóint Hkdf), ós rud é go mbeidh an eochair a ghintear, mar gheall ar thrasfhoirmiúlacht na bpéirí eochair rannpháirteacha, difriúil do gach seisiún agus go bhfuil go leor eantrópachta ann cheana féin. kdf.expand() de réir réamhshocraithe táirgeann sé na heochracha 256-giotán atá ag teastáil le haghaidh Dreoilín teaspaigh níos déanaí.

  Ansin, déantar na codanna TBE agus TBS den teachtaireacht isteach a sheiceáil:

  • déantar an MAC thar an téacs ciphersa isteach a ríomh agus a sheiceáil;
  • tá an ciphertext díchriptithe;
  • Tá struchtúr TBE díchódaithe;
  • tógtar aitheantóir an idirghabhálaí uaidh agus seiceáiltear an bhfuil sé ar eolas againn ar chor ar bith;
  • Déantar MAC thar an aitheantóir seo a ríomh agus a sheiceáil;
  • déantar an síniú thar an struchtúr TBS a fhíorú, lena n-áirítear fianán an dá pháirtí agus eochair ghearrshaolach phoiblí an pháirtí eile. Fíoraítear an síniú le heochair shínithe fhadtéarmach an idirghabhálaí.

   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"]
  

  Mar a scríobh mé thuas, tá cur síos ar 34.13/2015/XNUMX éagsúla bloc modhanna oibriúcháin cipher ón 34.12/2015/3413. Ina measc tá modh chun iatáin bréige agus ríomhanna MAC a ghiniúint. I PyGOST is é seo gost34.12.mac(). Éilíonn an modh seo an fheidhm criptithe a rith (bloc amháin sonraí a fháil agus a thabhairt ar ais), méid an bhloc criptithe agus, go deimhin, na sonraí féin. Cén fáth nach féidir leat méid an bhloc criptithe a chódú crua? Déanann 2015/128/64 cur síos ní amháin ar an XNUMX-giotán sifir dreoilín teaspaigh, ach freisin ar an XNUMX-giotán Magma - GOST 28147-89 beagán modhnaithe, a cruthaíodh ar ais sa KGB agus tá ceann de na tairseacha sábháilteachta is airde fós aige.

  Cuirtear tús le Kuznechik trí ghlao a chur ar gost.3412.GOST3412Kuznechik(eochair) agus cuireann sé réad ar ais le modhanna .cript()/.díchriptiú() atá oiriúnach lena chur ar aghaidh chuig 34.13 feidhmeanna. Ríomhtar MAC mar seo a leanas: gost3413.mac(GOST3412Kuznechik(eochair).cript, KUZNECHIK_BLOCKSIZE, ciphertext). Chun an MAC ríofa agus faighte a chur i gcomparáid, ní féidir leat an gnáthchomparáid (==) de na teaghráin bheart a úsáid, ós rud é go sceitheann an oibríocht seo am comparáide, rud a d'fhéadfadh, go ginearálta, leochaileachtaí marfach a bheith mar thoradh air. Beast ionsaithe ar TLS. Tá feidhm speisialta ag Python, hmac.compare_digest, chuige seo.

  Ní féidir leis an bhfeidhm bloc-scipéir ach bloc amháin sonraí a chriptiú. Le haghaidh líon níos mó, agus fiú nach iolraí den fhad, is gá an modh criptithe a úsáid. Déanann 34.13-2015 cur síos ar na nithe seo a leanas: BCE, CTR, OFB, CBC, CFB. Tá a réimsí iarratais agus tréithe inghlactha féin ag gach ceann acu. Ar an drochuair, níl caighdeánaithe againn fós modhanna criptithe fíordheimhnithe (cosúil le CCM, OCB, GCM agus a leithéid) - tá iallach orainn ar a laghad MAC a chur orainn féin. roghnaím mód cuntair (CTR): ní éilíonn sé stuáil le méid an bhloc, is féidir é a chomhthreomharú, ní úsáideann sé ach an fheidhm criptithe, is féidir é a úsáid go sábháilte chun líon mór teachtaireachtaí a chriptiú (murab ionann agus CBC, a bhfuil imbhuailtí sách tapa).

  Ar nós .mac(), glacann .ctr() ionchur comhchosúil: ciphertext = gost3413.ctr(GOST3412Kuznechik(eochair).cript, KUZNECHIK_BLOCKSIZE, gnáththéacs, iv). Tá sé riachtanach veicteoir tosaigh a shonrú atá díreach leath fhad an bhloic criptithe. Mura n-úsáidtear ár n-eochair chriptiúcháin ach chun teachtaireacht amháin a chriptiú (cé gur ó roinnt bloic), tá sé sábháilte veicteoir tosaigh nialasach a shocrú. Chun teachtaireachtaí croitheadh ​​láimhe a chriptiú, úsáidimid eochair ar leith gach uair.

  Is fánach an síniú gost3410.verify() a fhíorú: tugaimid thar an gcuar éilipseach ina bhfuilimid ag obair (ní dhéanaimid ach é a thaifeadadh inár bprótacal GOSTIM), eochair phoiblí an sínitheoir (ná déan dearmad gur chóir go mbeadh sé seo ina thuple de dhá líon mór, agus ní teaghrán beart), 34.11/2012/XNUMX hash agus an síniú féin.

  Ansin, sa thionscnóir déanaimid teachtaireacht chroitheadh ​​láimhe a ullmhú agus a sheoladh chuig handshake2, ag déanamh na ngníomhartha céanna agus a rinneamar le linn an fhíoraithe, go siméadrach amháin: síniú ar ár n-eochracha in ionad seiceáil, etc..

   456     # Prepare and send Handshake 2 message {{{
   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: session established: %s", _id, peer_name)
   

  Nuair a bhíonn an seisiún bunaithe, gintear eochracha iompair (eochair ar leith le haghaidh criptithe, fíordheimhnithe, do gach páirtí), agus cuirtear an Grasshopper ar dtús chun an MAC a dhíchriptiú agus a sheiceáil:

   499     # Run text message sender, initialize transport decoder {{{
   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     # Wait for test messages {{{
   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     # }}}
  

  Criptíonn coroutine msg_sender teachtaireachtaí anois sula seoltar ar nasc TCP iad. Tá méadú monatonach ag gach teachtaireacht, agus is é sin an veicteoir tosaigh freisin nuair a bhíonn sé criptithe i mód cuntair. Tá ráthaíocht ar chuntarluach difriúil ag gach teachtaireacht agus bloc teachtaireachta.

  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
  

  Déanann coroutine msg_receiver teachtaireachtaí isteach a phróiseáil, a láimhseálann fíordheimhniú agus díchriptiú:

  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)
  

  Conclúid

  Tá GOSTIM beartaithe le húsáid go heisiach chun críocha oideachais (ós rud é nach bhfuil sé clúdaithe ag tástálacha, ar a laghad)! Is féidir cód foinse an chláir a íoslódáil anseo (Стрибог-256 хэш: 995bbd368c04e50a481d138c5fa2e43ec7c89bc77743ba8dbabee1fde45de120). Как и все мои проекты, типа GoGOST, PyDERASN, NCCP, GoVPN, tá GOSTIM go hiomlán bogearraí saor in aiscedháileadh faoi na téarmaí GPLv3 +.

  Sergey Matveev, cipherpunk, ball Fondúireacht SPO, Python/Go-forbróir, príomhspeisialtóir Fiontraíocht Stáit Chónaidhme "STC "Atlas".

Foinse: will.com