GOSTIM: GOST ક્રિપ્ટોગ્રાફી સાથે એક સાંજે P2P F2F E2EE IM

વિકાસકર્તા બનવું PyGOST પુસ્તકાલયો (શુદ્ધ પાયથોનમાં GOST ક્રિપ્ટોગ્રાફિક પ્રિમિટિવ્સ), મને ઘણી વાર ઘૂંટણ પર સૌથી સરળ સુરક્ષિત મેસેજિંગ કેવી રીતે અમલમાં મૂકવું તે વિશે પ્રશ્નો પ્રાપ્ત થાય છે. ઘણા લોકો એપ્લાઇડ ક્રિપ્ટોગ્રાફીને એકદમ સરળ માને છે, અને બ્લોક સાઇફર પર .encrypt() ને કૉલ કરવું તેને સંચાર ચેનલ પર સુરક્ષિત રીતે મોકલવા માટે પૂરતું હશે. અન્ય લોકો માને છે કે એપ્લાઇડ ક્રિપ્ટોગ્રાફી એ થોડા લોકોનું નસીબ છે, અને તે સ્વીકાર્ય છે કે ઓલિમ્પિયાડ-ગણિતશાસ્ત્રીઓ સાથે ટેલિગ્રામ જેવી સમૃદ્ધ કંપનીઓ અમલ કરી શકતા નથી સુરક્ષિત પ્રોટોકોલ.

આ બધાએ મને આ લેખ લખવા માટે પ્રોત્સાહિત કર્યું કે તે બતાવવા માટે કે ક્રિપ્ટોગ્રાફિક પ્રોટોકોલ અને સુરક્ષિત IM અમલમાં મૂકવું એટલું મુશ્કેલ કાર્ય નથી. જો કે, તમારા પોતાના પ્રમાણીકરણ અને મુખ્ય કરાર પ્રોટોકોલની શોધ કરવી તે યોગ્ય નથી.

લેખ લખશે સહભાગી થી સહભાગી, મિત્ર થી મિત્ર, એન્ડ-ટુ-એન્ડ એન્ક્રિપ્ટેડ સાથે ઇન્સ્ટન્ટ મેસેન્જર સિગ્મા-I પ્રમાણીકરણ અને મુખ્ય કરાર પ્રોટોકોલ (જેના આધારે તે અમલમાં આવે છે IPsec IKE), ફક્ત GOST ક્રિપ્ટોગ્રાફિક અલ્ગોરિધમ્સ PyGOST લાઇબ્રેરી અને ASN.1 મેસેજ એન્કોડિંગ લાઇબ્રેરીનો ઉપયોગ કરીને PyDERASN (જેના વિશે હું પહેલેથી જ પહેલાં લખ્યું હતું). પૂર્વશરત: તે એટલું સરળ હોવું જોઈએ કે તે એક સાંજે (અથવા કામના દિવસે) શરૂઆતથી લખી શકાય, અન્યથા તે હવે સરળ પ્રોગ્રામ નથી. તેમાં સંભવતઃ ભૂલો, બિનજરૂરી ગૂંચવણો, ખામીઓ છે, ઉપરાંત એસિન્સિયો લાઇબ્રેરીનો ઉપયોગ કરીને આ મારો પ્રથમ પ્રોગ્રામ છે.

IM ડિઝાઇન

પ્રથમ, આપણે એ સમજવાની જરૂર છે કે આપણું IM કેવું દેખાશે. સરળતા માટે, સહભાગીઓની કોઈપણ શોધ વિના, તેને પીઅર-ટુ-પીઅર નેટવર્ક બનવા દો. અમે વ્યક્તિગત રીતે સૂચવીશું કે કયું સરનામું: ઇન્ટરલોક્યુટર સાથે વાતચીત કરવા માટે કનેક્ટ કરવા માટેનું પોર્ટ.

હું સમજું છું કે, આ સમયે, બે મનસ્વી કમ્પ્યુટર્સ વચ્ચે સીધો સંચાર ઉપલબ્ધ છે તેવી ધારણા એ વ્યવહારમાં IM ની લાગુ પડતી નોંધપાત્ર મર્યાદા છે. પરંતુ જેટલા વધુ વિકાસકર્તાઓ તમામ પ્રકારના NAT-ટ્રાવર્સલ ક્રૉચનો અમલ કરશે, તેટલા લાંબા સમય સુધી આપણે IPv4 ઈન્ટરનેટ પર રહીશું, જેમાં મનસ્વી કોમ્પ્યુટરો વચ્ચે સંચારની નિરાશાજનક સંભાવના છે. તમે ક્યાં સુધી ઘરે અને કામ પર IPv6 ના અભાવને સહન કરી શકો છો?

અમારી પાસે ફ્રેન્ડ-ટુ-ફ્રેન્ડ નેટવર્ક હશે: તમામ સંભવિત ઇન્ટરલોક્યુટર્સ અગાઉથી જાણીતા હોવા જોઈએ. સૌપ્રથમ, આ બધું ખૂબ જ સરળ બનાવે છે: અમે અમારી જાતને પરિચય આપ્યો, નામ/કી શોધી કે ન મળી, ડિસ્કનેક્ટ કર્યું અથવા કામ કરવાનું ચાલુ રાખ્યું, ઇન્ટરલોક્યુટરને જાણીને. બીજું, સામાન્ય રીતે, તે સુરક્ષિત છે અને ઘણા હુમલાઓને દૂર કરે છે.

IM ઇન્ટરફેસ ક્લાસિક સોલ્યુશન્સની નજીક હશે નિષ્ક્રિય પ્રોજેક્ટ્સ, જે મને તેમના મિનિમલિઝમ અને યુનિક્સ-વે ફિલસૂફી માટે ખરેખર ગમે છે. IM પ્રોગ્રામ દરેક ઇન્ટરલોક્યુટર માટે ત્રણ યુનિક્સ ડોમેન સોકેટ્સ સાથે ડિરેક્ટરી બનાવે છે:

• ઇન્ટરલોક્યુટરને મોકલવામાં આવેલા સંદેશાઓ તેમાં રેકોર્ડ કરવામાં આવે છે;
• આઉટ - ઇન્ટરલોક્યુટર તરફથી મળેલા સંદેશાઓ તેમાંથી વાંચવામાં આવે છે;
• રાજ્ય - તેમાંથી વાંચીને, અમે શોધી કાઢીએ છીએ કે ઇન્ટરલોક્યુટર હાલમાં જોડાયેલ છે કે કેમ, કનેક્શન સરનામું/પોર્ટ.

વધુમાં, એક કોન સોકેટ બનાવવામાં આવે છે, હોસ્ટ પોર્ટ લખીને જેમાં આપણે રિમોટ ઇન્ટરલોક્યુટર સાથે કનેક્શન શરૂ કરીએ છીએ.

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

આ અભિગમ તમને IM ટ્રાન્સપોર્ટ અને યુઝર ઇન્ટરફેસના સ્વતંત્ર અમલીકરણની મંજૂરી આપે છે, કારણ કે ત્યાં કોઈ મિત્ર નથી, તમે દરેકને ખુશ કરી શકતા નથી. ઉપયોગ કરીને tmux અને / અથવા મલ્ટિટેલ, તમે સિન્ટેક્સ હાઇલાઇટિંગ સાથે મલ્ટિ-વિન્ડો ઇન્ટરફેસ મેળવી શકો છો. અને મદદ સાથે rlwrap તમે GNU રીડલાઇન-સુસંગત સંદેશ ઇનપુટ લાઇન મેળવી શકો છો.

હકીકતમાં, સકલેસ પ્રોજેક્ટ્સ FIFO ફાઇલોનો ઉપયોગ કરે છે. અંગત રીતે, હું સમજી શકતો નથી કે સમર્પિત થ્રેડોમાંથી હાથથી લખેલી પૃષ્ઠભૂમિ વિના એસિન્સિયોમાં સ્પર્ધાત્મક રીતે ફાઇલો સાથે કેવી રીતે કામ કરવું (હું લાંબા સમયથી આવી વસ્તુઓ માટે ભાષાનો ઉપયોગ કરું છું. Go). તેથી, મેં યુનિક્સ ડોમેન સોકેટ્સ સાથે કરવાનું નક્કી કર્યું. કમનસીબે, આ ઇકો 2001:470:dead::babe 6666 > conn કરવાનું અશક્ય બનાવે છે. મેં આ સમસ્યાનો ઉપયોગ કરીને હલ કરી સોકેટ: echo 2001:470:dead::bebe 6666 | socat - UNIX-CONNECT:conn, socat READLINE UNIX-Connect:alice/in.

મૂળ અસુરક્ષિત પ્રોટોકોલ

TCP નો ઉપયોગ પરિવહન તરીકે થાય છે: તે ડિલિવરી અને તેના ઓર્ડરની ખાતરી આપે છે. UDP બાંયધરી આપતું નથી (જે સંકેતલિપીનો ઉપયોગ કરવામાં આવે ત્યારે ઉપયોગી થશે), પરંતુ સમર્થન આપે છે SCTP પાયથોન બોક્સમાંથી બહાર આવતું નથી.

કમનસીબે, TCP માં સંદેશનો કોઈ ખ્યાલ નથી, ફક્ત બાઈટનો પ્રવાહ છે. તેથી, સંદેશાઓ માટે એક ફોર્મેટ સાથે આવવું જરૂરી છે જેથી તેઓ આ થ્રેડમાં એકબીજા સાથે શેર કરી શકાય. અમે લાઇન ફીડ અક્ષરનો ઉપયોગ કરવા માટે સંમત થઈ શકીએ છીએ. શરૂઆત કરનારાઓ માટે તે સારું છે, પરંતુ એકવાર અમે અમારા સંદેશાઓને એન્ક્રિપ્ટ કરવાનું શરૂ કરી દઈએ, આ અક્ષર સાઇફર ટેક્સ્ટમાં ગમે ત્યાં દેખાઈ શકે છે. નેટવર્ક્સમાં, તેથી, લોકપ્રિય પ્રોટોકોલ તે છે જે પ્રથમ બાઈટમાં સંદેશની લંબાઈ મોકલે છે. ઉદાહરણ તરીકે, બોક્સની બહાર પાયથોનમાં xdrlib છે, જે તમને સમાન ફોર્મેટ સાથે કામ કરવાની મંજૂરી આપે છે. એક્સડીઆર.

અમે TCP વાંચન સાથે યોગ્ય રીતે અને અસરકારક રીતે કામ કરીશું નહીં - અમે કોડને સરળ બનાવીશું. અમે સંપૂર્ણ સંદેશને ડીકોડ ન કરીએ ત્યાં સુધી અમે સોકેટમાંથી ડેટાને અનંત લૂપમાં વાંચીએ છીએ. XML સાથે JSON નો ઉપયોગ આ અભિગમ માટે ફોર્મેટ તરીકે પણ થઈ શકે છે. પરંતુ જ્યારે ક્રિપ્ટોગ્રાફી ઉમેરવામાં આવે છે, ત્યારે ડેટા પર હસ્તાક્ષરિત અને પ્રમાણીકરણ કરવું પડશે - અને આ માટે ઑબ્જેક્ટ્સની બાઈટ-બદ-બાઈટ સમાન રજૂઆતની જરૂર પડશે, જે JSON/XML પ્રદાન કરતું નથી (ડમ્પ પરિણામો અલગ-અલગ હોઈ શકે છે).

XDR આ કાર્ય માટે યોગ્ય છે, જો કે હું DER એન્કોડિંગ સાથે ASN.1 પસંદ કરું છું અને PyDERASN પુસ્તકાલય, કારણ કે અમારી પાસે ઉચ્ચ-સ્તરની વસ્તુઓ હશે જેની સાથે તે કામ કરવા માટે ઘણીવાર વધુ સુખદ અને અનુકૂળ હોય છે. સ્કીમલેસથી વિપરીત બેનકોડ, મેસેજપેક અથવા CBOR, ASN.1 હાર્ડ-કોડેડ સ્કીમા સામે આપમેળે ડેટા તપાસશે.

# 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 હશે: કાં તો ટેક્સ્ટ MsgText (હમણાં માટે એક ટેક્સ્ટ ફીલ્ડ સાથે) અથવા MsgHandshake હેન્ડશેક સંદેશ (જેમાં ઇન્ટરલોક્યુટરનું નામ છે). હવે તે વધુ જટિલ લાગે છે, પરંતુ આ ભવિષ્ય માટેનો પાયો છે.

     ┌─────┐ ┌─────┐ │PeerA│ │PeerB│ └──┬┘──┘ ── IdA) │ │───────── ─────│ │ │ MsgText() │ │──── MsgText() │ │ │

ક્રિપ્ટોગ્રાફી વિના IM

મેં પહેલેથી જ કહ્યું તેમ, asyncio લાઇબ્રેરીનો ઉપયોગ તમામ સોકેટ કામગીરી માટે કરવામાં આવશે. ચાલો જાહેરાત કરીએ કે અમે લોન્ચ સમયે શું અપેક્ષા રાખીએ છીએ:

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

તમારું પોતાનું નામ સેટ કરો (--અમારું-નામ એલિસ). બધા અપેક્ષિત ઇન્ટરલોક્યુટર્સને અલ્પવિરામ દ્વારા અલગ કરીને સૂચિબદ્ધ કરવામાં આવે છે (—તેમના-નામ બોબ, ઇવ). દરેક ઇન્ટરલોક્યુટર્સ માટે, યુનિક્સ સોકેટ્સ સાથેની ડિરેક્ટરી બનાવવામાં આવે છે, તેમજ દરેક ઇન, આઉટ, સ્ટેટ માટે કોરોટીન બનાવવામાં આવે છે:

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

ઇન સોકેટમાંથી વપરાશકર્તા તરફથી આવતા સંદેશાઓ 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"))

ઇન્ટરલોક્યુટર્સ તરફથી આવતા સંદેશાઓ OUT_QUEUES કતારોમાં મોકલવામાં આવે છે, જેમાંથી ડેટા આઉટ સોકેટ પર લખવામાં આવે છે:

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

સ્ટેટ સોકેટમાંથી વાંચતી વખતે, પ્રોગ્રામ PEER_ALIVE શબ્દકોશમાં ઇન્ટરલોક્યુટરનું સરનામું શોધે છે. જો હજી સુધી ઇન્ટરલોક્યુટર સાથે કોઈ કનેક્શન નથી, તો ખાલી લાઇન લખવામાં આવે છે.

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

કોન સોકેટ પર સરનામું લખતી વખતે, કનેક્શન "પ્રારંભિક" કાર્ય શરૂ થાય છે:

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

ચાલો આરંભકર્તાને ધ્યાનમાં લઈએ. પ્રથમ તે સ્પષ્ટપણે ઉલ્લેખિત હોસ્ટ/પોર્ટ સાથે કનેક્શન ખોલે છે અને તેના નામ સાથે હેન્ડશેક સંદેશ મોકલે છે:

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

પછી, તે રિમોટ પાર્ટી તરફથી પ્રતિસાદની રાહ જુએ છે. Msg ASN.1 સ્કીમનો ઉપયોગ કરીને આવનારા પ્રતિભાવને ડીકોડ કરવાનો પ્રયાસ કરે છે. અમે ધારીએ છીએ કે આખો સંદેશ એક TCP સેગમેન્ટમાં મોકલવામાં આવશે અને .read() કૉલ કરતી વખતે અમે તેને પરમાણુ રીતે પ્રાપ્ત કરીશું. અમે તપાસીએ છીએ કે અમને હેન્ડશેક સંદેશ મળ્યો છે.

 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     # }}}

અમે તપાસ કરીએ છીએ કે ઇન્ટરલોક્યુટરનું પ્રાપ્ત નામ અમને જાણીતું છે. જો નહીં, તો અમે જોડાણ તોડી નાખીએ છીએ. અમે તપાસીએ છીએ કે અમે તેની સાથે પહેલેથી જ જોડાણ સ્થાપિત કર્યું છે (વાર્તાકારે ફરીથી અમારી સાથે કનેક્ટ થવાનો આદેશ આપ્યો) અને તેને બંધ કરો. IN_QUEUES કતાર સંદેશના ટેક્સ્ટ સાથે પાયથોન સ્ટ્રીંગ ધરાવે છે, પરંતુ તેમાં None નું વિશેષ મૂલ્ય છે જે msg_sender coroutine ને કામ કરવાનું બંધ કરવા માટે સંકેત આપે છે જેથી તે લેગસી 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     # }}}

msg_sender આઉટગોઇંગ સંદેશાઓ સ્વીકારે છે (એક ઇન સોકેટમાંથી કતારમાં), તેમને MsgText સંદેશમાં શ્રેણીબદ્ધ કરે છે અને TCP કનેક્શન પર મોકલે છે. તે કોઈપણ ક્ષણે તૂટી શકે છે - અમે આને સ્પષ્ટપણે અટકાવીએ છીએ.

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

અંતે, આરંભકર્તા સોકેટમાંથી સંદેશાઓ વાંચવાના અનંત લૂપમાં પ્રવેશ કરે છે. આ સંદેશાઓ ટેક્સ્ટ સંદેશાઓ છે કે કેમ તે તપાસે છે અને તેમને OUT_QUEUES કતારમાં મૂકે છે, જ્યાંથી તે સંબંધિત ઇન્ટરલોક્યુટરના આઉટ સોકેટ પર મોકલવામાં આવશે. શા માટે તમે ફક્ત .read() કરી શકતા નથી અને સંદેશને ડીકોડ કરી શકતા નથી? કારણ કે તે શક્ય છે કે વપરાશકર્તાના ઘણા સંદેશાઓ ઓપરેટિંગ સિસ્ટમ બફરમાં એકત્ર કરવામાં આવશે અને એક TCP સેગમેન્ટમાં મોકલવામાં આવશે. અમે પ્રથમ ડીકોડ કરી શકીએ છીએ, અને પછીના ભાગનો ભાગ બફરમાં રહી શકે છે. કોઈપણ અસામાન્ય પરિસ્થિતિના કિસ્સામાં, અમે TCP કનેક્શન બંધ કરીએ છીએ અને msg_sender coroutine (OUT_QUEUES કતારમાં None મોકલીને) બંધ કરીએ છીએ.

 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)

ચાલો મુખ્ય કોડ પર પાછા ફરીએ. પ્રોગ્રામ શરૂ થાય તે સમયે તમામ કોરોટીન બનાવ્યા પછી, અમે TCP સર્વર શરૂ કરીએ છીએ. દરેક સ્થાપિત કનેક્શન માટે, તે પ્રતિભાવ આપનાર કોરોટીન બનાવે છે.

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

પ્રતિસાદ આપનાર શરૂઆતકર્તા જેવો જ છે અને બધી જ ક્રિયાઓને પ્રતિબિંબિત કરે છે, પરંતુ સરળતા માટે, સંદેશાઓ વાંચવાનું અનંત લૂપ તરત જ શરૂ થાય છે. હાલમાં, હેન્ડશેક પ્રોટોકોલ દરેક બાજુથી એક સંદેશ મોકલે છે, પરંતુ ભવિષ્યમાં કનેક્શન આરંભકર્તા તરફથી બે હશે, જેના પછી તરત જ ટેક્સ્ટ સંદેશા મોકલી શકાય છે.

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

સુરક્ષિત પ્રોટોકોલ

અમારા સંચારને સુરક્ષિત કરવાનો આ સમય છે. સુરક્ષાનો અમારો અર્થ શું છે અને અમને શું જોઈએ છે:

• પ્રસારિત સંદેશાઓની ગુપ્તતા;
• પ્રસારિત સંદેશાઓની અધિકૃતતા અને અખંડિતતા - તેમના ફેરફારો શોધવામાં આવશ્યક છે;
• રીપ્લે હુમલા સામે રક્ષણ - ગુમ થયેલ અથવા પુનરાવર્તિત સંદેશાઓની હકીકત શોધવી આવશ્યક છે (અને અમે કનેક્શન સમાપ્ત કરવાનું નક્કી કરીએ છીએ);
• પૂર્વ-દાખલ કરેલ સાર્વજનિક કીઓનો ઉપયોગ કરીને ઇન્ટરલોક્યુટર્સની ઓળખ અને પ્રમાણીકરણ - અમે પહેલાથી જ નક્કી કર્યું છે કે અમે મિત્ર-થી-મિત્ર નેટવર્ક બનાવી રહ્યા છીએ. પ્રમાણીકરણ પછી જ આપણે સમજી શકીશું કે આપણે કોની સાથે વાતચીત કરી રહ્યા છીએ;
• પ્રાપ્યતા સંપૂર્ણ ફોરવર્ડ ગુપ્તતા પ્રોપર્ટીઝ (PFS) - અમારી લાંબા સમયથી ચાલતી સાઈનિંગ કી સાથે ચેડા કરવાથી અગાઉના તમામ પત્રવ્યવહાર વાંચવાની ક્ષમતા ન હોવી જોઈએ. રેકોર્ડિંગ અટકાવાયેલ ટ્રાફિક નકામું બની જાય છે;
• માત્ર એક TCP સત્રમાં સંદેશાઓની માન્યતા/માન્યતા (પરિવહન અને હેન્ડશેક). બીજા સત્રમાંથી યોગ્ય રીતે હસ્તાક્ષરિત/પ્રમાણિત સંદેશાઓ દાખલ કરવા (સમાન ઇન્ટરલોક્યુટર સાથે પણ) શક્ય ન હોવા જોઈએ;
• નિષ્ક્રિય નિરીક્ષકે ક્યાં તો વપરાશકર્તા ઓળખકર્તાઓ, લાંબા સમયથી પ્રસારિત જાહેર કી, અથવા તેમાંથી હેશ જોવી જોઈએ નહીં. નિષ્ક્રિય નિરીક્ષક તરફથી ચોક્કસ અનામી.

આશ્ચર્યજનક રીતે, લગભગ દરેક જણ કોઈપણ હેન્ડશેક પ્રોટોકોલમાં આ ન્યૂનતમ રાખવા માંગે છે, અને ઉપરોક્તમાંથી બહુ ઓછા "વતન" પ્રોટોકોલ માટે આખરે મળ્યા છે. હવે અમે કંઈપણ નવું શોધીશું નહીં. હું ચોક્કસપણે ઉપયોગ કરવાની ભલામણ કરીશ ઘોંઘાટનું માળખું પ્રોટોકોલ બનાવવા માટે, પરંતુ ચાલો કંઈક સરળ પસંદ કરીએ.

બે સૌથી લોકપ્રિય પ્રોટોકોલ છે:

• TLS - બગ્સ, જૅમ્બ્સ, નબળાઈઓ, નબળા વિચાર, જટિલતા અને ખામીઓનો લાંબો ઇતિહાસ ધરાવતો ખૂબ જ જટિલ પ્રોટોકોલ (જો કે, આનો TLS 1.3 સાથે બહુ ઓછો સંબંધ છે). પરંતુ અમે તેને ધ્યાનમાં લેતા નથી કારણ કે તે વધુ જટિલ છે.
• IPsec с આઇકેઇ — ગંભીર ક્રિપ્ટોગ્રાફિક સમસ્યાઓ નથી, જો કે તે સરળ પણ નથી. જો તમે IKEv1 અને IKEv2 વિશે વાંચો છો, તો તેમનો સ્ત્રોત છે એસટીએસ, ISO/IEC IS 9798-3 અને SIGMA (SIGn-and-MAc) પ્રોટોકોલ - એક સાંજે અમલ કરવા માટે પૂરતા સરળ.

STS/ISO પ્રોટોકોલના વિકાસમાં નવીનતમ કડી તરીકે SIGMA વિશે શું સારું છે? તે અમારી બધી આવશ્યકતાઓને પૂર્ણ કરે છે ("છુપાવવા" ઇન્ટરલોક્યુટર ઓળખકર્તાઓ સહિત) અને તેમાં કોઈ જાણીતી ક્રિપ્ટોગ્રાફિક સમસ્યાઓ નથી. તે ન્યૂનતમ છે - પ્રોટોકોલ સંદેશમાંથી ઓછામાં ઓછા એક ઘટકને દૂર કરવાથી તેની અસુરક્ષા તરફ દોરી જશે.

ચાલો સૌથી સરળ ઘરેલુ પ્રોટોકોલથી SIGMA પર જઈએ. અમને રસ છે તે સૌથી મૂળભૂત કામગીરી છે મુખ્ય કરાર: એક કાર્ય કે જે બંને સહભાગીઓને સમાન મૂલ્ય આઉટપુટ કરે છે, જેનો ઉપયોગ સપ્રમાણ કી તરીકે થઈ શકે છે. વિગતોમાં ગયા વિના: દરેક પક્ષો ક્ષણિક (ફક્ત એક સત્રમાં વપરાયેલ) કી જોડી (જાહેર અને ખાનગી કી) જનરેટ કરે છે, સાર્વજનિક કીની આપલે કરે છે, એગ્રીમેન્ટ ફંક્શનને કૉલ કરે છે, જેના ઇનપુટમાં તેઓ તેમની ખાનગી કી અને જાહેર જનતાને પાસ કરે છે. ઇન્ટરલોક્યુટરની ચાવી.

┌────│ │ ╔══════════ ══════════╗ │────────────────────>│ ║PrvA(PrvA), ═ ═════════ ═══════════╝ │ IdB, PubB │ ╔═════════════════════════ │<───────── ──────│ ║PrvB, PubB = DHgen()║ │ │ ╚════════════════════════════ ───┐ ╔════ ═══╧════════════╗ │ ║Key = DH(PrvA, PubB)║ <───║ <───┘══════════════════ ═══════ ════╝ │ │ │ │

કોઈપણ મધ્યમાં કૂદી શકે છે અને સાર્વજનિક કીને તેમની પોતાની સાથે બદલી શકે છે - આ પ્રોટોકોલમાં ઇન્ટરલોક્યુટર્સનું કોઈ પ્રમાણીકરણ નથી. ચાલો લાંબા ગાળાની ચાવીઓ સાથે સહી ઉમેરીએ.

┌─────┐ ┌─────┐ │PeerA│ │PeerB│ └──┬┘A─┘ ── ચિહ્ન(SignPrvA, (PubA)) │ ╔═ │──────────── ────────── ──└Aign ubA = લોડ()║ │ │ ║PrvA, PubA = DHgen() ║ │ │ ╚═══════ ═══════ ════════════════════ , ચિહ્ન (PrvB, (PubB)) │ ╔═══└═══════════ ════════════════════ ─────────── ───────────── ──│ ║SignPrvB, SignPubB = load( )║ │ │ ║PrvB, PubB = DH ═════════ ══════════════ ══╝ ────┐ ╔ ═══════════════ ═════╗ │ │ ║ચકાસો( SignPubB, ...)║ │ <───┘ ║Key = DH(Pr vA, PubB) ║ │ │ ╚════════════════════════ ═╝ │ │ │

આવા હસ્તાક્ષર કામ કરશે નહીં, કારણ કે તે ચોક્કસ સત્ર સાથે જોડાયેલ નથી. આવા સંદેશાઓ અન્ય સહભાગીઓ સાથેના સત્રો માટે પણ "યોગ્ય" છે. સમગ્ર સંદર્ભે સબ્સ્ક્રાઇબ કરવું આવશ્યક છે. આ અમને A તરફથી બીજો સંદેશ ઉમેરવાની ફરજ પાડે છે.

વધુમાં, સહી હેઠળ તમારા પોતાના ઓળખકર્તાને ઉમેરવું મહત્વપૂર્ણ છે, કારણ કે અન્યથા અમે IdXXX ને બદલી શકીએ છીએ અને અન્ય જાણીતા ઇન્ટરલોક્યુટરની કી વડે સંદેશ પર ફરીથી સહી કરી શકીએ છીએ. અટકાવવા પ્રતિબિંબ હુમલા, તે જરૂરી છે કે હસ્તાક્ષર હેઠળના તત્વો તેમના અર્થ અનુસાર સ્પષ્ટ રીતે વ્યાખ્યાયિત સ્થાનો પર હોય: જો A ચિહ્નો (PubA, PubB), તો B દ્વારા સહી કરવી આવશ્યક છે (PubB, PubA). આ શ્રેણીબદ્ધ ડેટાના બંધારણ અને ફોર્મેટને પસંદ કરવાના મહત્વ વિશે પણ વાત કરે છે. ઉદાહરણ તરીકે, ASN.1 DER એન્કોડિંગમાં સેટને સૉર્ટ કરવામાં આવે છે: SET OF(PubA, PubB) SET OF(PubB, PubA) સમાન હશે.

┌────│ │ ╔══════════ ═════════════════╗ │─────────────────────── ────────── - ═ ═══════ ═══════════════╝ │IdB, PubB, ચિહ્ન(SignPrvB, (IdB, PubA, PubB)) │ ═════════════ ═════ ════════════╗ │<──────────────────────────── ────────── ─────────│ ║SignPrvB, SignPubB = load()║ │ │ ║PrvB, PubB = DHgen() ║ │ │ │ ═ ═ ═ ═ ═ ═════════ ══════════╝ │ ચિહ્ન(SignPrvA, (IdA, PubB, PubA)) │ ╔═════════════════════ ════╗ │─ ─────────────────────────└──────── ───>│ ║ચકાસો(SignPubB, ...) ║ │ │ ║key = dh (prva, PUBB) ║ │ │ │

જો કે, અમે હજી પણ "સાબિત" નથી કર્યું કે અમે આ સત્ર માટે સમાન શેર કરેલી કી જનરેટ કરી છે. સૈદ્ધાંતિક રીતે, અમે આ પગલા વિના કરી શકીએ છીએ - પ્રથમ પરિવહન કનેક્શન અમાન્ય હશે, પરંતુ અમે ઇચ્છીએ છીએ કે જ્યારે હેન્ડશેક પૂર્ણ થાય, ત્યારે અમે ખાતરી કરીશું કે બધું ખરેખર સંમત છે. અત્યારે અમારી પાસે ISO/IEC IS 9798-3 પ્રોટોકોલ છે.

અમે જનરેટ કરેલી કી પર જ સહી કરી શકીએ છીએ. આ ખતરનાક છે, કારણ કે સંભવ છે કે ઉપયોગમાં લેવાતા હસ્તાક્ષર અલ્ગોરિધમમાં લીક થઈ શકે છે (બિટ્સ-પ્રતિ-સિગ્નેચર હોવા છતાં, પરંતુ હજુ પણ લીક થાય છે). વ્યુત્પન્ન કીના હેશ પર સહી કરવી શક્ય છે, પરંતુ વ્યુત્પન્ન કીના હેશને લીક કરવું પણ વ્યુત્પન્ન કાર્ય પરના બ્રુટ-ફોર્સ હુમલામાં મૂલ્યવાન હોઈ શકે છે. SIGMA MAC ફંક્શનનો ઉપયોગ કરે છે જે પ્રેષક ID ને પ્રમાણિત કરે છે.

┌────│ │ ╔══════════ ═════════════════╗ │─────────────────────── ────────── ──────────────────>│ ║SignPrvA, SignPubA = load()║ │ │ ║Prv()║ │ │ ║ Prv ╚ ═══════ ═- ═══ │<───────────────── ────────────────── ────────── ─│ ║SignPrvB, SignPubB = load()║ │ │ ║PrvB, PubB = DHgen() ║ │ │ ╚══════════════════ ═════════ - │ ║ કી = DH( PrvA, PubB) ║ │─────────────────────────────────────── ────────── ─────>│ ║ચકાસો(કી, IdB) ║ │ │ ║ચકાસો(SignPubB, ...)║ │ │ ╚═════════════════════ ═════ ═╝ │ │

ઑપ્ટિમાઇઝેશન તરીકે, કેટલાક તેમની ક્ષણિક કીનો ફરીથી ઉપયોગ કરવા માંગે છે (જે અલબત્ત, PFS માટે કમનસીબ છે). ઉદાહરણ તરીકે, અમે એક કી જોડી બનાવી, કનેક્ટ કરવાનો પ્રયાસ કર્યો, પરંતુ TCP ઉપલબ્ધ નહોતું અથવા પ્રોટોકોલની મધ્યમાં ક્યાંક વિક્ષેપિત થયો હતો. નવી જોડી પર વ્યર્થ એન્ટ્રોપી અને પ્રોસેસર સંસાધનોનો બગાડ કરવો શરમજનક છે. તેથી, અમે કહેવાતી કૂકી રજૂ કરીશું - એક સ્યુડો-રેન્ડમ મૂલ્ય કે જે ક્ષણિક જાહેર કીનો ફરીથી ઉપયોગ કરતી વખતે સંભવિત રેન્ડમ રીપ્લે હુમલાઓ સામે રક્ષણ કરશે. કૂકી અને ક્ષણિક જાહેર કી વચ્ચેના બંધનને કારણે, વિરોધી પક્ષની જાહેર કી બિનજરૂરી તરીકે સહીમાંથી દૂર કરી શકાય છે.

┌─────┐ ┌─────┐ │PeerA│ │PeerB│ └──┬┘ Ib── કૂકીએ │ ╔════════ ═══════════════════╗ │────└────────── ────────── ─────────────────────────└──────── ─>│ ║SignPrvA, SignPubA = લોડ( )║ │ │ ║PrvA, PubA = DHgen() ║ │ │ ╚═════════════════════════════ ══╝ │IdB, PubB, CookieB , sign(SignPrvB, (CookieA, CookieB, PubB)), MAC(IdB) │ ╔═══════════════════════════════ ═ ╗ │< ─────────────────────────└──────── ────────── - │ ╚══════ ══════════════════════╝ │ │ ╔════════════ ═══════╗ │ ચિહ્ન( SignPrvA, (CookieB, CookieA, PubA)), MAC(IdA) │ ║Key = DH(PrvA, PubB) ║ │────────────────────────────── ─ ── ─────────────────────────└──────── ───────>│ ║ ચકાસો(કી, IdB) ║ │ │ ║ચકાસો(SignPubB, ...)║ │ │ ╚══════════════════════════════ │ │

અંતે, અમે નિષ્ક્રિય નિરીક્ષક પાસેથી અમારા વાતચીત ભાગીદારોની ગોપનીયતા મેળવવા માંગીએ છીએ. આ કરવા માટે, SIGMA એ પ્રથમ ક્ષણિક કીની આપલે કરવાનો પ્રસ્તાવ મૂકે છે અને એક સામાન્ય કી વિકસાવે છે જેના પર પ્રમાણીકરણ અને સંદેશાઓને ઓળખી શકાય છે. સિગ્મા બે વિકલ્પોનું વર્ણન કરે છે:

• SIGMA-I - આરંભકર્તાને સક્રિય હુમલાઓથી, પ્રતિસાદકર્તાને નિષ્ક્રિય હુમલાઓથી રક્ષણ આપે છે: આરંભકર્તા પ્રતિસાદ આપનારને પ્રમાણિત કરે છે અને જો કંઈક મેળ ખાતું નથી, તો તે તેની ઓળખ આપતું નથી. જો તેની સાથે સક્રિય પ્રોટોકોલ શરૂ કરવામાં આવે તો પ્રતિવાદી તેની ઓળખ આપે છે. નિષ્ક્રિય નિરીક્ષક કંઈ શીખતો નથી;
  સિગ્મા-આર - સક્રિય હુમલાઓથી પ્રતિસાદ આપનારનું રક્ષણ કરે છે, નિષ્ક્રિય લોકોથી આરંભ કરનારને. બધું બરાબર વિરુદ્ધ છે, પરંતુ આ પ્રોટોકોલમાં ચાર હેન્ડશેક સંદેશાઓ પહેલાથી જ પ્રસારિત થાય છે.

  અમે SIGMA-I પસંદ કરીએ છીએ કારણ કે તે ક્લાયંટ-સર્વર પરિચિત વસ્તુઓ પાસેથી આપણે જે અપેક્ષા રાખીએ છીએ તેના જેવું જ છે: ક્લાયંટને માત્ર પ્રમાણિત સર્વર દ્વારા જ ઓળખવામાં આવે છે, અને દરેક જણ સર્વરને પહેલેથી જ જાણે છે. ઉપરાંત ઓછા હેન્ડશેક સંદેશાને કારણે તેને અમલમાં મૂકવું સરળ છે. અમે પ્રોટોકોલમાં જે ઉમેરીએ છીએ તે સંદેશના ભાગને એન્ક્રિપ્ટ કરવાનું છે અને ઓળખકર્તા A ને છેલ્લા સંદેશના એન્ક્રિપ્ટેડ ભાગમાં સ્થાનાંતરિત કરવાનું છે:

  PubA, CookieA │ ╔═════════════════════════════════════════ ─────────── ───── ────────── ──────────────────── ─────────── ───── ──────>│ ║SignPrvA , SignPubA = load()║ │ │ ║PrvA, PubA = DHgen() ║ ╂ ═════════ . ═══════════════ ═══════╗ │<─└─────────── ────────── - ════════ ════════════════╝ │ │ ╔═══════════════ ══╗ │ Enc((IdA, ચિહ્ન( SignPrvA, (CookieB, CookieA, PubA)), MAC(IdA))) │ ║Key = DH(PrvA, PubB) ║ │────────────────────────────── ─ ────────────────── ──────────────── ─────────── ──────>│ ║ચકાસો(કી, IdB) ║ │ │ ║ચકાસો( SignPubB, ...)║ │ │ ╚════════════════════ ═════ ══╝ │ │
  

  • GOST R નો ઉપયોગ સહી માટે થાય છે 34.10-2012 256-બીટ કી સાથે અલ્ગોરિધમ.
  • સાર્વજનિક કી જનરેટ કરવા માટે, 34.10-2012 VKO નો ઉપયોગ થાય છે.
  • CMAC નો ઉપયોગ MAC તરીકે થાય છે. તકનીકી રીતે, આ GOST R 34.13-2015 માં વર્ણવેલ બ્લોક સાઇફરની કામગીરીનો એક વિશિષ્ટ મોડ છે. આ મોડ માટે એન્ક્રિપ્શન ફંક્શન તરીકે - ખડમાકડી (34.12-2015).
  • તેની સાર્વજનિક કીના હેશનો ઉપયોગ ઇન્ટરલોક્યુટરના ઓળખકર્તા તરીકે થાય છે. હેશ તરીકે વપરાય છે સ્ટ્રિબોગ-256 (34.11/2012/256 XNUMX બિટ્સ).

  હેન્ડશેક પછી, અમે શેર કરેલી કી પર સંમત થઈશું. અમે તેનો ઉપયોગ પરિવહન સંદેશાઓના અધિકૃત એન્ક્રિપ્શન માટે કરી શકીએ છીએ. આ ભાગ ખૂબ જ સરળ અને ભૂલ કરવી મુશ્કેલ છે: અમે મેસેજ કાઉન્ટરને વધારીએ છીએ, મેસેજને એન્ક્રિપ્ટ કરીએ છીએ, કાઉન્ટરને પ્રમાણિત (MAC) કરીએ છીએ અને સાઇફરટેક્સ્ટ મોકલીએ છીએ. સંદેશ પ્રાપ્ત કરતી વખતે, અમે તપાસીએ છીએ કે કાઉન્ટર પાસે અપેક્ષિત મૂલ્ય છે, કાઉન્ટર સાથે સાઇફરટેક્સ્ટને પ્રમાણિત કરો અને તેને ડિક્રિપ્ટ કરો. હેન્ડશેક સંદેશાઓ એન્ક્રિપ્ટ કરવા, સંદેશાઓ પરિવહન કરવા અને તેમને કેવી રીતે પ્રમાણિત કરવા માટે મારે કઈ કીનો ઉપયોગ કરવો જોઈએ? આ બધા કાર્યો માટે એક કીનો ઉપયોગ કરવો જોખમી અને અવિવેકી છે. વિશિષ્ટ કાર્યોનો ઉપયોગ કરીને કીઓ જનરેટ કરવી જરૂરી છે કેડીએફ (કી વ્યુત્પન્ન કાર્ય). ફરીથી, ચાલો વાળ વિભાજીત ન કરીએ અને કંઈક શોધ કરીએ: એચ.કે.ડી.એફ. લાંબા સમયથી જાણીતું છે, સારી રીતે સંશોધન કરવામાં આવ્યું છે અને કોઈ જાણીતી સમસ્યાઓ નથી. કમનસીબે, મૂળ પાયથોન લાઇબ્રેરીમાં આ કાર્ય નથી, તેથી અમે ઉપયોગ કરીએ છીએ hkdf પ્લાસ્ટિક બેગ. HKDF આંતરિક રીતે ઉપયોગ કરે છે HMAC, જે બદલામાં હેશ ફંક્શનનો ઉપયોગ કરે છે. વિકિપીડિયા પૃષ્ઠ પર પાયથોનમાં એક ઉદાહરણ અમલીકરણ કોડની થોડીક લાઇન લે છે. 34.10/2012/256 ના કિસ્સામાં, આપણે હેશ ફંક્શન તરીકે સ્ટ્રિબોગ-XNUMX નો ઉપયોગ કરીશું. અમારા કી એગ્રીમેન્ટ ફંક્શનના આઉટપુટને સેશન કી કહેવામાં આવશે, જેમાંથી ગુમ થયેલ સપ્રમાણ જનરેટ થશે:

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

  માળખા/યોજનાઓ

  ચાલો જોઈએ કે આ તમામ ડેટા ટ્રાન્સમિટ કરવા માટે હવે આપણી પાસે કઈ ASN.1 સ્ટ્રક્ચર્સ છે:

  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)
  

  હેન્ડશેકટીબીએસ પર હસ્તાક્ષર કરવામાં આવશે. હેન્ડશેકટીબીઇ - શું એન્ક્રિપ્ટ કરવામાં આવશે. હું તમારું ધ્યાન MsgHandshake1 માં ukm ફીલ્ડ તરફ દોરું છું. 34.10 VKO, જનરેટ કરેલી કીના વધુ રેન્ડમાઇઝેશન માટે, UKM (યુઝર કીઇંગ મટિરિયલ) પેરામીટરનો સમાવેશ કરે છે - માત્ર વધારાની એન્ટ્રોપી.

  કોડમાં ક્રિપ્ટોગ્રાફી ઉમેરવાનું

  ચાલો મૂળ કોડમાં કરવામાં આવેલા ફેરફારોને જ ધ્યાનમાં લઈએ, કારણ કે ફ્રેમવર્ક સમાન રહ્યું (હકીકતમાં, અંતિમ અમલીકરણ પહેલા લખવામાં આવ્યું હતું, અને પછી તેમાંથી તમામ સંકેતલિપીને કાપી નાખવામાં આવી હતી).

  સાર્વજનિક કીઓનો ઉપયોગ કરીને પ્રમાણીકરણ અને ઇન્ટરલોક્યુટર્સની ઓળખ હાથ ધરવામાં આવશે, તેથી તેમને હવે ક્યાંક લાંબા સમય સુધી સંગ્રહિત કરવાની જરૂર છે. સરળતા માટે, અમે આ રીતે JSON નો ઉપયોગ કરીએ છીએ:

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

  અમારી - અમારી કી જોડી, હેક્સાડેસિમલ ખાનગી અને જાહેર કી. તેમના — વાર્તાલાપ કરનારાઓના નામ અને તેમની જાહેર ચાવીઓ. ચાલો આદેશ વાક્ય દલીલો બદલીએ અને JSON ડેટાની પોસ્ટ-પ્રોસેસિંગ ઉમેરીએ:

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

  34.10 અલ્ગોરિધમની ખાનગી કી એક રેન્ડમ નંબર છે. 256-બીટ લંબગોળ વણાંકો માટે 256-બીટ કદ. PyGOST બાઇટ્સના સમૂહ સાથે કામ કરતું નથી, પરંતુ સાથે મોટી સંખ્યામાં, તેથી અમારી ખાનગી કી (યુરેન્ડમ(32)) ને gost3410.prv_unmarshal() નો ઉપયોગ કરીને નંબરમાં રૂપાંતરિત કરવાની જરૂર છે. જાહેર કી gost3410.public_key() નો ઉપયોગ કરીને ખાનગી કીમાંથી નિર્ધારિત રીતે નક્કી કરવામાં આવે છે. સાર્વજનિક કી 34.10 એ બે મોટી સંખ્યાઓ છે જેને gost3410.pub_marshal() નો ઉપયોગ કરીને સ્ટોરેજ અને ટ્રાન્સમિશનની સરળતા માટે બાઈટ સિક્વન્સમાં રૂપાંતરિત કરવાની પણ જરૂર છે.

  JSON ફાઇલ વાંચ્યા પછી, તે મુજબ સાર્વજનિક કીને gost3410.pub_unmarshal() નો ઉપયોગ કરીને પાછી રૂપાંતરિત કરવાની જરૂર છે. અમને સાર્વજનિક કીમાંથી હેશના રૂપમાં ઇન્ટરલોક્યુટર્સના ઓળખકર્તાઓ પ્રાપ્ત થશે, તેથી તેઓ તરત જ અગાઉથી ગણતરી કરી શકાય છે અને ઝડપી શોધ માટે શબ્દકોશમાં મૂકી શકાય છે. Stribog-256 hash gost34112012256.GOST34112012256(), જે હેશ ફંક્શન્સના હેશલિબ ઇન્ટરફેસને સંપૂર્ણ રીતે સંતુષ્ટ કરે છે.

  આરંભ કરનાર કોરોટીન કેવી રીતે બદલાઈ છે? બધું હેન્ડશેક યોજના મુજબ છે: અમે એક કૂકી (128-બીટ પુષ્કળ છે), એક ક્ષણિક કી જોડી 34.10 જનરેટ કરીએ છીએ, જેનો ઉપયોગ 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()
  

  • અમે પ્રતિસાદની રાહ જોઈએ છીએ અને આવનારા સંદેશને ડીકોડ કરીએ છીએ;
  • ખાતરી કરો કે તમે હેન્ડશેક1 મેળવો છો;
  • વિરોધી પક્ષની ક્ષણિક સાર્વજનિક કીને ડીકોડ કરો અને સત્ર કીની ગણતરી કરો;
  • અમે સંદેશના TBE ભાગની પ્રક્રિયા કરવા માટે જરૂરી સપ્રમાણ કીઓ જનરેટ કરીએ છીએ.

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

  UKM એ 64-બીટ નંબર છે (યુરેન્ડમ(8)), જેને gost3410_vko.ukm_unmarshal() નો ઉપયોગ કરીને તેના બાઈટ પ્રતિનિધિત્વમાંથી ડીસીરિયલાઈઝેશનની પણ જરૂર છે. 34.10/2012/256 માટે VKO ફંક્શન 3410-bit gost34102012256_vko.kek_XNUMX() (KEK - એન્ક્રિપ્શન કી) છે.

  જનરેટ કરેલ સત્ર કી પહેલેથી જ 256-બીટ સ્યુડો-રેન્ડમ બાઈટ સિક્વન્સ છે. તેથી, તેનો તરત જ HKDF કાર્યોમાં ઉપયોગ કરી શકાય છે. GOST34112012256 hashlib ઈન્ટરફેસને સંતુષ્ટ કરતું હોવાથી, તેનો તરત જ Hkdf વર્ગમાં ઉપયોગ કરી શકાય છે. અમે મીઠું (Hkdf ની પ્રથમ દલીલ) નો ઉલ્લેખ કરતા નથી, કારણ કે જનરેટ કરેલ કી, સહભાગી કી જોડીની ક્ષણિકતાને કારણે, દરેક સત્ર માટે અલગ હશે અને તે પહેલાથી જ પૂરતી એન્ટ્રોપી ધરાવે છે. kdf.expand() મૂળભૂત રીતે પહેલાથી જ ગ્રાશોપર માટે જરૂરી 256-બીટ કીઓનું ઉત્પાદન કરે છે.

  આગળ, આવનારા સંદેશાના TBE અને TBS ભાગો તપાસવામાં આવે છે:

  • ઇનકમિંગ સિફરટેક્સ્ટ પર MAC ની ગણતરી કરવામાં આવે છે અને તપાસવામાં આવે છે;
  • સાઇફરટેક્સ્ટ ડિક્રિપ્ટ થયેલ છે;
  • TBE માળખું ડીકોડ થયેલ છે;
  • ઇન્ટરલોક્યુટરની ઓળખકર્તા તેની પાસેથી લેવામાં આવે છે અને તે તપાસવામાં આવે છે કે તે આપણને બિલકુલ ઓળખે છે કે કેમ;
  • આ ઓળખકર્તા પર MAC ની ગણતરી અને તપાસ કરવામાં આવે છે;
  • TBS સ્ટ્રક્ચર પરની સહી ચકાસવામાં આવે છે, જેમાં બંને પક્ષોની કૂકી અને વિરોધી પક્ષની સાર્વજનિક ક્ષણિક કીનો સમાવેશ થાય છે. હસ્તાક્ષર ઇન્ટરલોક્યુટરની લાંબા ગાળાની સહી કી દ્વારા ચકાસવામાં આવે છે.

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

  મેં ઉપર લખ્યું તેમ, 34.13/2015/XNUMX વિવિધ વર્ણન કરે છે બ્લોક સાઇફર ઓપરેટિંગ મોડ્સ 34.12/2015/3413 થી. તેમાંથી અનુકરણ દાખલ અને MAC ગણતરીઓ જનરેટ કરવા માટે એક મોડ છે. PyGOST માં આ gost34.12.mac() છે. આ મોડ માટે એન્ક્રિપ્શન ફંક્શન (ડેટાનો એક બ્લોક મેળવવો અને પરત કરવો), એન્ક્રિપ્શન બ્લોકનું કદ અને હકીકતમાં, ડેટા પોતે જ પસાર કરવો જરૂરી છે. શા માટે તમે એન્ક્રિપ્શન બ્લોકના કદને હાર્ડકોડ કરી શકતા નથી? 2015/128/64 માત્ર XNUMX-બીટ ગ્રાશોપર સાઇફર જ નહીં, પણ XNUMX-બીટનું પણ વર્ણન કરે છે મેગ્મા - સહેજ સંશોધિત GOST 28147-89, કેજીબીમાં પાછું બનાવવામાં આવ્યું છે અને હજુ પણ ઉચ્ચતમ સુરક્ષા થ્રેશોલ્ડમાંનું એક છે.

  કુઝનેચિકને gost.3412.GOST3412Kuznechik(key) પર કૉલ કરીને પ્રારંભ કરવામાં આવે છે અને 34.13 ફંક્શનમાં પસાર કરવા માટે યોગ્ય .encrypt()/.decrypt() પદ્ધતિઓ વડે ઑબ્જેક્ટ પરત કરે છે. MAC ની ગણતરી નીચે પ્રમાણે કરવામાં આવે છે: gost3413.mac(GOST3412Kuznechik(key).encrypt, KUZNECHIK_BLOCKSIZE, સાઇફરટેક્સ્ટ). ગણતરી કરેલ અને પ્રાપ્ત કરેલ MAC ની સરખામણી કરવા માટે, તમે બાઈટ સ્ટ્રીંગ્સની સામાન્ય સરખામણી (==) નો ઉપયોગ કરી શકતા નથી, કારણ કે આ કામગીરી સરખામણી સમયને લીક કરે છે, જે સામાન્ય કિસ્સામાં, ઘાતક નબળાઈઓ તરફ દોરી શકે છે જેમ કે બીસ્ટ TLS પર હુમલા. આ માટે પાયથોન પાસે ખાસ કાર્ય છે, hmac.compare_digest.

  બ્લોક સાઇફર ફંક્શન ડેટાના માત્ર એક બ્લોકને એન્ક્રિપ્ટ કરી શકે છે. મોટી સંખ્યા માટે, અને લંબાઈના ગુણાંક માટે પણ, એન્ક્રિપ્શન મોડનો ઉપયોગ કરવો જરૂરી છે. 34.13-2015 નીચેનાનું વર્ણન કરે છે: ECB, CTR, OFB, CBC, CFB. દરેક પાસે એપ્લિકેશન અને લાક્ષણિકતાઓના તેના પોતાના સ્વીકાર્ય ક્ષેત્રો છે. કમનસીબે, અમારી પાસે હજુ પણ પ્રમાણભૂત નથી પ્રમાણિત એન્ક્રિપ્શન મોડ્સ (જેમ કે CCM, OCB, GCM અને તેના જેવા) - અમને ઓછામાં ઓછું MAC ઉમેરવાની ફરજ પડી છે. હું પસંદ કરું છું કાઉન્ટર મોડ (CTR): તેને બ્લોકના કદમાં પેડિંગની જરૂર નથી, સમાંતર કરી શકાય છે, માત્ર એન્ક્રિપ્શન ફંક્શનનો ઉપયોગ કરે છે, મોટી સંખ્યામાં સંદેશાઓને એન્ક્રિપ્ટ કરવા માટે સુરક્ષિત રીતે ઉપયોગ કરી શકાય છે (CBCથી વિપરીત, જે પ્રમાણમાં ઝડપથી અથડામણ કરે છે).

  .mac(), .ctr() ની જેમ સમાન ઇનપુટ લે છે: ciphertext = gost3413.ctr(GOST3412Kuznechik(key).encrypt, KUZNECHIK_BLOCKSIZE, સાદો ટેક્સ્ટ, iv). એન્ક્રિપ્શન બ્લોકની બરાબર અડધી લંબાઈ ધરાવતા પ્રારંભિક વેક્ટરનો ઉલ્લેખ કરવો જરૂરી છે. જો અમારી એન્ક્રિપ્શન કીનો ઉપયોગ ફક્ત એક સંદેશને એન્ક્રિપ્ટ કરવા માટે કરવામાં આવે છે (ઘણા બ્લોકમાંથી હોવા છતાં), તો શૂન્ય આરંભ વેક્ટર સેટ કરવું સલામત છે. હેન્ડશેક સંદેશાને એન્ક્રિપ્ટ કરવા માટે, અમે દરેક વખતે અલગ કીનો ઉપયોગ કરીએ છીએ.

  હસ્તાક્ષર gost3410.verify() ની ચકાસણી કરવી તુચ્છ છે: અમે જે લંબગોળ વળાંકને અંદરથી પસાર કરીએ છીએ (અમે તેને અમારા GOSTIM પ્રોટોકોલમાં રેકોર્ડ કરીએ છીએ), સહી કરનારની સાર્વજનિક કી (ભૂલશો નહીં કે આ બેનો ટુપલ હોવો જોઈએ. મોટી સંખ્યાઓ, અને બાઈટ સ્ટ્રિંગ નહીં), 34.11/2012/XNUMX હેશ અને સહી પોતે.

  આગળ, ઇનિશિયેટરમાં અમે હેન્ડશેક 2 ને હેન્ડશેક મેસેજ તૈયાર કરીએ છીએ અને મોકલીએ છીએ, અમે વેરિફિકેશન દરમિયાન જે ક્રિયાઓ કરી હતી તે જ ક્રિયાઓ કરીને, માત્ર સમપ્રમાણરીતે: ચેક કરવાને બદલે અમારી કી પર સહી કરવી વગેરે...

   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)
   

  જ્યારે સત્ર સ્થાપિત થાય છે, ત્યારે ટ્રાન્સપોર્ટ કીઓ જનરેટ થાય છે (એનક્રિપ્શન માટે એક અલગ કી, પ્રમાણીકરણ માટે, દરેક પક્ષો માટે), અને ગ્રાસશોપરને MAC ને ડિક્રિપ્ટ કરવા અને તપાસવા માટે પ્રારંભ કરવામાં આવે છે:

   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     # }}}
  

  msg_sender કોરોટીન હવે સંદેશાઓને TCP કનેક્શન પર મોકલતા પહેલા એન્ક્રિપ્ટ કરે છે. દરેક સંદેશમાં એકવિધ રીતે વધતી જતી નોન્સ હોય છે, જે જ્યારે કાઉન્ટર મોડમાં એન્ક્રિપ્ટ કરવામાં આવે ત્યારે આરંભ વેક્ટર પણ હોય છે. દરેક સંદેશ અને સંદેશ બ્લોકની અલગ કાઉન્ટર કિંમત હોવાની ખાતરી આપવામાં આવે છે.

  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
  

  આવનારા સંદેશાઓ msg_receiver કોરોટીન દ્વારા પ્રક્રિયા કરવામાં આવે છે, જે પ્રમાણીકરણ અને ડિક્રિપ્શનને હેન્ડલ કરે છે:

  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)
  

  નિષ્કર્ષ

  GOSTIM નો ઉપયોગ ફક્ત શૈક્ષણિક હેતુઓ માટે કરવાનો છે (કારણ કે તે ઓછામાં ઓછું પરીક્ષણો દ્વારા આવરી લેવામાં આવતું નથી)! પ્રોગ્રામનો સોર્સ કોડ ડાઉનલોડ કરી શકાય છે અહીં (Стрибог-256 хэш: 995bbd368c04e50a481d138c5fa2e43ec7c89bc77743ba8dbabee1fde45de120). Как и все мои проекты, типа GoGOST, PyDERASN, એન.એન.સી.પી., GoVPN, GOSTIM સંપૂર્ણપણે છે મફત સોફ્ટવેર, શરતો હેઠળ વિતરિત GPLv3 +.

  સેર્ગેઈ માત્વીવ, સાયફરપંક, સભ્ય SPO ફાઉન્ડેશન, Python/Go વિકાસકર્તા, મુખ્ય નિષ્ણાત FSUE "STC "એટલાસ".

સોર્સ: www.habr.com