GOSTIM: GOST क्रिप्टोग्राफीको साथ एक साँझमा P2P F2F E2EE IM

विकासकर्ता भएर PyGOST पुस्तकालयहरू (शुद्ध पाइथनमा GOST क्रिप्टोग्राफिक प्रिमिटिवहरू), म प्रायः घुँडामा सबैभन्दा सरल सुरक्षित सन्देश कसरी कार्यान्वयन गर्ने भन्ने बारे प्रश्नहरू प्राप्त गर्छु। धेरै मानिसहरूले लागू गरिएको क्रिप्टोग्राफीलाई एकदम सरल मान्छन्, र ब्लक साइफरमा .encrypt() लाई कल गर्दा यसलाई संचार च्यानलमा सुरक्षित रूपमा पठाउन पर्याप्त हुनेछ। अरूहरू विश्वास गर्छन् कि लागू गरिएको क्रिप्टोग्राफी थोरैको भाग्य हो, र यो स्वीकार्य छ कि ओलम्पियाड-गणितज्ञहरूसँग टेलिग्राम जस्ता धनी कम्पनीहरू। कार्यान्वयन गर्न सक्दैन सुरक्षित प्रोटोकल।

यी सबैले मलाई यो लेख लेख्न प्रेरित गर्‍यो कि क्रिप्टोग्राफिक प्रोटोकलहरू लागू गर्न र सुरक्षित IM त्यस्तो गाह्रो काम होइन। यद्यपि, यो तपाईंको आफ्नै प्रमाणीकरण र प्रमुख सम्झौता प्रोटोकलहरू आविष्कार गर्न लायक छैन।

लेख लेख्ने हो पियर टु पियर, साथी-साथी, अन्त-देखि-अन्त इन्क्रिप्टेड तत्काल दूत संग SIGMA-I प्रमाणीकरण र प्रमुख सम्झौता प्रोटोकल (जसको आधारमा यो लागू गरिएको छ IPsec IKE), विशेष रूपमा GOST क्रिप्टोग्राफिक एल्गोरिदम PyGOST पुस्तकालय र ASN.1 सन्देश इन्कोडिङ लाइब्रेरी प्रयोग गर्दै PyDERASN (जसको बारेमा म पहिले नै पहिले लेखे)। एक शर्त: यो यति सरल हुनुपर्छ कि यसलाई एक साँझ (वा कार्यदिवस) मा स्क्र्याचबाट लेख्न सकिन्छ, अन्यथा यो अब साधारण कार्यक्रम छैन। यसमा त्रुटिहरू, अनावश्यक जटिलताहरू, कमजोरीहरू छन्, साथै यो asyncio पुस्तकालय प्रयोग गरेर मेरो पहिलो कार्यक्रम हो।

IM डिजाइन

पहिले, हामीले हाम्रो IM कस्तो देखिन्छ भनेर बुझ्न आवश्यक छ। सरलताको लागि, यसलाई सहभागीहरूको कुनै पनि खोज बिना, एक सहकर्मी-देखि-सहकर्मी नेटवर्क हुन दिनुहोस्। हामी व्यक्तिगत रूपमा कुन ठेगाना संकेत गर्नेछौं: अन्तर्वार्ताकर्तासँग कुराकानी गर्न पोर्ट जडान गर्न।

म बुझ्छु कि, यस समयमा, दुई स्वेच्छाचारी कम्प्युटरहरू बीच प्रत्यक्ष संचार उपलब्ध छ भन्ने धारणा IM को व्यावहारिकतामा महत्त्वपूर्ण सीमितता हो। तर जति धेरै विकासकर्ताहरूले सबै प्रकारका NAT-ट्राभर्सल क्रचहरू लागू गर्छन्, हामी उति लामो समयसम्म IPv4 इन्टरनेटमा रहनेछौं, अनियन्त्रित कम्प्युटरहरू बीच सञ्चारको निराशाजनक सम्भावनाको साथ। तपाईं घर र काममा IPv6 को अभाव कहिलेसम्म सहन सक्नुहुन्छ?

हामीसँग एक मित्र-बाट-मित्र नेटवर्क हुनेछ: सबै सम्भावित अन्तर्वार्ताकर्ताहरूलाई पहिले नै थाहा हुनुपर्छ। सबैभन्दा पहिले, यसले सबै कुरालाई धेरै सरल बनाउँछ: हामीले आफैलाई परिचय दियौं, नाम/कुञ्जी फेला पारेनौं, विच्छेद भयो वा काम जारी राख्छौं, वार्ताकारलाई थाहा छ। दोस्रो, सामान्यतया, यो सुरक्षित छ र धेरै आक्रमणहरू हटाउँछ।

IM इन्टरफेस क्लासिक समाधानको नजिक हुनेछ बेकार परियोजनाहरू, जुन मलाई साँच्चै तिनीहरूको minimalism र Unix-way दर्शनको लागि मनपर्छ। IM कार्यक्रमले प्रत्येक अन्तर्वार्ताकर्ताको लागि तीन युनिक्स डोमेन सकेटहरूको साथ डाइरेक्टरी सिर्जना गर्दछ:

• अन्तरवार्ताकर्तालाई पठाइएका सन्देशहरू यसमा रेकर्ड गरिएका छन्;
• बाहिर - वार्ताकारबाट प्राप्त सन्देशहरू यसबाट पढिन्छन्;
• राज्य - यसबाट पढेर, हामी पत्ता लगाउँछौं कि अन्तर्वार्ताकर्ता हाल जडान भएको छ, जडान ठेगाना/पोर्ट।

थप रूपमा, एक कन्न सकेट सिर्जना गरिएको छ, होस्ट पोर्ट लेखेर जसमा हामी रिमोट इन्टरलोक्यूटरमा जडान सुरु गर्छौं।

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

यो दृष्टिकोणले तपाईंलाई IM यातायात र प्रयोगकर्ता इन्टरफेसको स्वतन्त्र कार्यान्वयन गर्न अनुमति दिन्छ, किनकि त्यहाँ कुनै साथी छैन, तपाईं सबैलाई खुसी पार्न सक्नुहुन्न। प्रयोग गर्दै tmux र / वा मल्टिटाइल, तपाईले सिन्ट्याक्स हाइलाइटिङको साथ बहु-विन्डो इन्टरफेस प्राप्त गर्न सक्नुहुन्छ। र सहयोग संग rlwrap तपाईंले GNU Readline-compatible सन्देश इनपुट लाइन प्राप्त गर्न सक्नुहुन्छ।

वास्तवमा, suckless परियोजनाहरूले FIFO फाइलहरू प्रयोग गर्छन्। व्यक्तिगत रूपमा, मैले समर्पित थ्रेडहरूबाट हातले लेखिएको पृष्ठभूमि बिना asyncio मा प्रतिस्पर्धात्मक रूपमा फाइलहरूसँग कसरी काम गर्ने भनेर बुझ्न सकिन (मैले लामो समयदेखि त्यस्ता चीजहरूको लागि भाषा प्रयोग गर्दै आएको छु। Go)। त्यसकारण, मैले युनिक्स डोमेन सकेटहरूसँग गर्ने निर्णय गरें। दुर्भाग्यवश, यसले echo 2001:470:dead::babe 6666 > conn गर्न असम्भव बनाउँछ। मैले प्रयोग गरेर यो समस्या समाधान गरें socat: echo 2001:470:dead::bebe 6666 | socat - UNIX-CONNECT:conn, socat READLINE UNIX-Connect:alice/in।

मूल असुरक्षित प्रोटोकल

TCP यातायातको रूपमा प्रयोग गरिन्छ: यसले डेलिभरी र यसको अर्डरको ग्यारेन्टी गर्दछ। UDP ले ग्यारेन्टी दिदैन (जुन क्रिप्टोग्राफी प्रयोग गर्दा उपयोगी हुनेछ), तर समर्थन SCTP पाइथन बक्सबाट बाहिर आउँदैन।

दुर्भाग्यवश, TCP मा सन्देशको कुनै अवधारणा छैन, केवल बाइटहरूको स्ट्रिम। तसर्थ, सन्देशहरूको लागि ढाँचाको साथ आउन आवश्यक छ ताकि तिनीहरू यस थ्रेडमा आपसमा साझा गर्न सकिन्छ। हामी लाइन फिड क्यारेक्टर प्रयोग गर्न सहमत हुन सक्छौं। यो शुरुवातका लागि राम्रो छ, तर हामीले हाम्रा सन्देशहरू गुप्तिकरण गर्न सुरु गरेपछि, यो क्यारेक्टर सिफरटेक्स्टमा जहाँ पनि देखा पर्न सक्छ। सञ्जालहरूमा, त्यसकारण, लोकप्रिय प्रोटोकलहरू ती हुन् जसले पहिले सन्देशको लम्बाइ बाइटहरूमा पठाउँछन्। उदाहरणका लागि, पाइथनमा xdrlib छ, जसले तपाईंलाई समान ढाँचामा काम गर्न अनुमति दिन्छ। XDR.

हामीले TCP पढाइसँग सही र प्रभावकारी रूपमा काम गर्ने छैनौं - हामी कोडलाई सरल बनाउनेछौं। हामीले पूरा सन्देश डिकोड नगरेसम्म हामी सकेटबाट डाटा अनन्त लुपमा पढ्छौं। XML सँग JSON पनि यस दृष्टिकोणको लागि ढाँचाको रूपमा प्रयोग गर्न सकिन्छ। तर जब क्रिप्टोग्राफी थपिन्छ, डाटामा हस्ताक्षर र प्रमाणीकरण गर्नुपर्नेछ - र यसका लागि वस्तुहरूको बाइट-फर-बाइट समान प्रतिनिधित्व आवश्यक पर्दछ, जुन JSON/XML ले प्रदान गर्दैन (डम्प परिणामहरू भिन्न हुन सक्छन्)।

XDR यस कार्यको लागि उपयुक्त छ, यद्यपि म DER एन्कोडिङ र ASN.1 छनौट गर्छु PyDERASN पुस्तकालय, किनकि हामीसँग हातमा उच्च-स्तरका वस्तुहरू हुनेछन् जसको साथ यो काम गर्न धेरै रमाइलो र सुविधाजनक हुन्छ। योजनाविहीन विपरीत बेनकोड, MessagePack वा 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) │ │───────── ────────>│ │ │ │MsgHandshake(IdB) │ │<─────│────│ │ │ 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()

त्यसपछि, यो टाढाको पार्टीबाट प्रतिक्रियाको लागि पर्खन्छ। सन्देश 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 с ike - गम्भीर क्रिप्टोग्राफिक समस्याहरू छैनन्, यद्यपि तिनीहरू पनि सरल छैनन्। यदि तपाईंले IKEv1 र IKEv2 बारे पढ्नुभयो भने, तिनीहरूको स्रोत हो एसटीएस, ISO/IEC IS 9798-3 र SIGMA (SIGn-and-MAc) प्रोटोकलहरू - एक साँझ लागू गर्न पर्याप्त सरल।

STS/ISO प्रोटोकलहरूको विकासमा नवीनतम लिङ्कको रूपमा SIGMA को बारेमा के राम्रो छ? यसले हाम्रा सबै आवश्यकताहरू पूरा गर्दछ ("लुकाउने" अन्तर्वार्ताकर्ता पहिचानकर्ताहरू सहित) र कुनै ज्ञात क्रिप्टोग्राफिक समस्याहरू छैनन्। यो न्यूनतम छ - प्रोटोकल सन्देशबाट कम्तिमा एउटा तत्व हटाउनाले यसको असुरक्षा निम्त्याउँछ।

सिग्मामा सबैभन्दा सरल घरेलु प्रोटोकलबाट जाऔं। हामीले चासो राखेको सबैभन्दा आधारभूत अपरेशन हो प्रमुख सम्झौता: एक प्रकार्य जसले दुबै सहभागीहरूलाई समान मान आउटपुट गर्दछ, जुन सिमेट्रिक कुञ्जीको रूपमा प्रयोग गर्न सकिन्छ। विवरणहरूमा नगईकन: प्रत्येक पक्षले क्षणिक (एउटा सत्रमा मात्र प्रयोग गरिएको) कुञ्जी जोडी (सार्वजनिक र निजी कुञ्जीहरू) उत्पन्न गर्दछ, सार्वजनिक कुञ्जीहरू साटासाट गर्दछ, सम्झौता प्रकार्यलाई कल गर्दछ, जसको इनपुटमा उनीहरूले आफ्नो निजी कुञ्जी र सार्वजनिक पार्छन्। वार्ताकारको कुञ्जी।

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

जो कोहीले बीचमा हाम फाल्न सक्छन् र सार्वजनिक कुञ्जीहरू आफ्नैसँग बदल्न सक्छन् - यस प्रोटोकलमा अन्तर्वार्ताकर्ताहरूको कुनै प्रमाणीकरण छैन। दिर्घकालिन कुञ्जीहरूसँग हस्ताक्षर थपौं।

┌─────┐ ┌─────┐ │PeerA│ │PeerB│ └──┬──┘ ──│, P चिन्ह (SignPrvA, (PubA)) │ ╔═ │──────────── ────────── ──┑──────────── ubA = लोड()║ │ │ ║PrvA, PubA = DHgen() ║ │ │ ╚═════════════════════════════════════ , चिन्ह (SignPrvB, (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) सँग समान हुनेछ।

┌─────┐ ┌─────┐ │PeerA│ │PeerB│ └──┬──┘ ──│ Aub │ ╔══════════ ═════════════════╗ │────────────────────── ────────── ─────────────>│ ║SignPrvA, SignPubA = load()║ │ │ ║PrvA, PubA = DHgen ╔ ═ ═══════ ═══════════════╝ │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 ले प्रेषक ID प्रमाणीकरण गर्ने MAC प्रकार्य प्रयोग गर्दछ।

┌─────┐ ┌─────┐ │PeerA│ │PeerB│ └──┬──┘ ──│ Aub │ ╔══════════ ═════════════════╗ │────────────────────── ────────── ──────────────────>│ ║SignPrvA, SignPubA = load()║ │ │ ║Prv()║ │ │ ║Prv() ╚ ═══════ ═- ═══ │<───────────────── ─────────────────── ────────── ─│ ║SignPrvB, SignPubB = load()║ │ │ ║PrvB, PubB = DHgen() ║ │ │ ╚═══════════════════ ═════════ ══╝ │ │ ╔════════════ ════════════════ Pv चिन्ह │ ║ कुञ्जी = DH( PrvA, PubB) ║ │─────────────────────────────────────── ────────── ─────>│ ║प्रमाणित (कुञ्जी, IdB) ║ │ │ ║प्रमाणित(साइन पबबी, ...)║ │ │ ╚═══════════════════════ ═════ ═╝ │ │

एक अप्टिमाइजेसनको रूपमा, कोही-कोहीले आफ्नो अल्पकालिक कुञ्जीहरू पुन: प्रयोग गर्न चाहन्छन् (जुन पक्कै पनि पीएफएसको लागि दुर्भाग्यपूर्ण छ)। उदाहरणका लागि, हामीले एउटा कुञ्जी जोडा उत्पन्न गर्यौं, जडान गर्ने प्रयास गर्‍यौं, तर TCP उपलब्ध थिएन वा प्रोटोकलको बीचमा कतै अवरोध भयो। यो नयाँ जोडीमा बर्बाद एन्ट्रोपी र प्रोसेसर स्रोतहरू बर्बाद गर्न लाजमर्दो कुरा हो। तसर्थ, हामी तथाकथित कुकी प्रस्तुत गर्नेछौं - एक छद्म-यादृच्छिक मान जसले क्षणिक सार्वजनिक कुञ्जीहरू पुन: प्रयोग गर्दा सम्भावित अनियमित पुन: प्ले आक्रमणहरू विरुद्ध सुरक्षा गर्नेछ। कुकी र अल्पकालिक सार्वजनिक कुञ्जी बीचको बन्धनका कारण, विपरित पक्षको सार्वजनिक कुञ्जीलाई अनावश्यक रूपमा हस्ताक्षरबाट हटाउन सकिन्छ।

┌─────┐ ┌─────┐ │PeerA│ │PeerB│ └──┬──┘ ──│, P कुकीए │ ╔════════ ══════════════════╗ │───────────────── ────────── ────────────────────────────────────── ─>│ ║SignPrvA, SignPubA = लोड( )║ │ │ ║PrvA, PubA = DHgen() ║ │ │ ╚═══════════════════════════════ ══╝ │IdB, PubB, कुकीबी चिन्ह ═ ╗ │< ────────────────────────────────────── ────────── * │ ╚══════ ═════════════════════╝ │ │ ╔════════════ ═══════╗ │ चिन्ह ( SignPrvA, (CookieB, CookieA, PubA)), MAC(IdA) │ ║Key = DH(PrvA, PubB) ║ │─────────────────────────────── ─ ── ────────────────────────────────────── ───────>│ ║ verify(Key, IdB) ║ │ │ ║प्रमाणित (SignPubB, ...)║ │ │ ╚══════════════════════════════ │ │

अन्तमा, हामी निष्क्रिय पर्यवेक्षकबाट हाम्रा कुराकानी साझेदारहरूको गोपनीयता प्राप्त गर्न चाहन्छौं। यसो गर्नको लागि, SIGMA ले पहिलो पटक अल्पकालिक कुञ्जीहरू आदानप्रदान गर्ने र सन्देशहरूलाई प्रमाणीकरण र पहिचान गर्ने इन्क्रिप्ट गर्ने साझा कुञ्जी विकास गर्ने प्रस्ताव गर्दछ। SIGMA ले दुई विकल्पहरू वर्णन गर्दछ:

• SIGMA-I - सक्रिय आक्रमणहरूबाट शुरुवातकर्तालाई बचाउँछ, निष्क्रियहरूबाट प्रतिक्रियाकर्ता: प्रारम्भकर्ताले प्रतिक्रियाकर्तालाई प्रमाणीकरण गर्दछ र यदि केहि मेल खाँदैन भने, त्यसले आफ्नो पहिचान दिँदैन। प्रतिवादीले आफ्नो परिचय दिन्छ यदि उनीसँग सक्रिय प्रोटोकल सुरु हुन्छ। निष्क्रिय पर्यवेक्षकले केही सिक्दैन;
  SIGMA-R - सक्रिय आक्रमणहरूबाट प्रतिक्रियाकर्तालाई बचाउँछ, निष्क्रियहरूबाट शुरुवातकर्ता। सबै ठीक उल्टो छ, तर यस प्रोटोकलमा चार ह्यान्डशेक सन्देशहरू पहिले नै प्रसारित छन्।

  हामी SIGMA-I छनौट गर्छौं किनकि यो क्लाइन्ट-सर्भर परिचित चीजहरूबाट हामीले अपेक्षा गरेको कुरासँग मिल्दोजुल्दो छ: क्लाइन्टलाई प्रमाणीकृत सर्भरले मात्र मान्यता दिन्छ, र सबैलाई पहिले नै सर्भर थाहा छ। साथै कम ह्यान्डशेक सन्देशहरूको कारण कार्यान्वयन गर्न सजिलो छ। हामीले प्रोटोकलमा थप्ने भनेको सन्देशको अंश इन्क्रिप्ट गर्नु र पहिचानकर्ता A लाई अन्तिम सन्देशको इन्क्रिप्टेड भागमा स्थानान्तरण गर्नु हो:

  PubA, CookieA │ ╔══════════ ══════════════════════════════════════ ─────────── ───── ────────── ──────────────────────── ─────────── ───── ──────>│ ║SignPrvA , SignPubA = load()║ │ │ ║PrvA, PubA = DHgen() ║ ┕ ═ DHgen ═════════ ═══════════════════ │ │ │ │ │ │ │ ││b, usiB ((IDB, चिन्ह (spabvb), म्याक (आईडीबी)) ═══════════════ ═══════╗ │<─└─────────── ────────── ───── ────────── ║SignP rvB, SignPubB = load()║ │ │ ─── ──── ════════ ════════════════╝ │ │ ╔════════════════ ══╗ │ Enc((IdA, चिन्ह( SignPrvA, (CookieB, CookieA, PubA)), MAC(IdA))) │ ║Key = DH(PrvA, PubB) ║ │────────────────────────────── ─ ────────────────── ───────────────────── ─────────── + ═════ ══╝ │ │
  

  • GOST R हस्ताक्षरको लागि प्रयोग गरिन्छ 34.10-2012 256-बिट कुञ्जीहरूसँग एल्गोरिथ्म।
  • सार्वजनिक कुञ्जी उत्पन्न गर्न, 34.10-2012 VKO प्रयोग गरिन्छ।
  • CMAC MAC को रूपमा प्रयोग गरिन्छ। प्राविधिक रूपमा, यो GOST R 34.13-2015 मा वर्णन गरिएको ब्लक सिफरको सञ्चालनको एक विशेष मोड हो। यस मोडको लागि एन्क्रिप्शन प्रकार्यको रूपमा - टिभी (34.12-2015)।
  • उसको सार्वजनिक कुञ्जीको ह्यास अन्तर्वार्ताकर्ताको पहिचानकर्ताको रूपमा प्रयोग गरिन्छ। ह्यासको रूपमा प्रयोग गरिन्छ Stribog-256 (34.11/2012/256 XNUMX बिट)।

  ह्यान्डशेक पछि, हामी साझा कुञ्जीमा सहमत हुनेछौं। हामी यसलाई यातायात सन्देशहरूको प्रमाणीकृत इन्क्रिप्शनको लागि प्रयोग गर्न सक्छौं। यो भाग धेरै सरल र गल्ती गर्न गाह्रो छ: हामी सन्देश काउन्टर बढाउँछौं, सन्देश इन्क्रिप्ट गर्छौं, काउन्टरलाई प्रमाणीकरण (MAC) र सिफरटेक्स्ट पठाउँछौं। सन्देश प्राप्त गर्दा, हामी काउन्टरमा अपेक्षित मान छ भनेर जाँच गर्छौं, काउन्टरसँग सिफरटेक्स्ट प्रमाणीकरण गर्नुहोस्, र यसलाई डिक्रिप्ट गर्नुहोस्। ह्यान्डशेक सन्देशहरू, ट्रान्सपोर्ट सन्देशहरू, र तिनीहरूलाई कसरी प्रमाणीकरण गर्ने भनेर इन्क्रिप्ट गर्न मैले कुन कुञ्जी प्रयोग गर्नुपर्छ? यी सबै कार्यहरूका लागि एउटै कुञ्जी प्रयोग गर्नु खतरनाक र मूर्खतापूर्ण छ। विशेष प्रकार्यहरू प्रयोग गरेर कुञ्जीहरू उत्पन्न गर्न आवश्यक छ KDF (कुञ्जी व्युत्पन्न प्रकार्य)। फेरि, कपाल विभाजित नगरौं र केहि आविष्कार गरौं: HKDF लामो समयदेखि ज्ञात छ, राम्रोसँग अनुसन्धान गरिएको छ र कुनै ज्ञात समस्याहरू छैनन्। दुर्भाग्यवश, नेटिभ पाइथन लाइब्रेरीमा यो प्रकार्य छैन, त्यसैले हामी प्रयोग गर्छौं hkdf प्लास्टिक झोला। HKDF आन्तरिक रूपमा प्रयोग गर्दछ HMAC, जसले बारीमा ह्यास प्रकार्य प्रयोग गर्दछ। विकिपिडिया पृष्ठमा पाइथनमा उदाहरण कार्यान्वयनले कोडको केही लाइनहरू मात्र लिन्छ। 34.10/2012/256 को मामला मा, हामी ह्यास प्रकार्य को रूप मा Stribog-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)
  

  HandshakeTBS के हस्ताक्षर हुनेछ। HandshakeTBE - के ईन्क्रिप्टेड हुनेछ। म तपाईको ध्यान 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 बाइट्स को एक सेट संग काम गर्दैन, तर संग ठूलो संख्या, त्यसैले हाम्रो निजी कुञ्जी (urandom(32)) लाई gost3410.prv_unmarshal() प्रयोग गरेर नम्बरमा रूपान्तरण गर्न आवश्यक छ। सार्वजनिक कुञ्जी gost3410.public_key() प्रयोग गरेर निजी कुञ्जीबाट निश्चित रूपमा निर्धारण गरिन्छ। सार्वजनिक कुञ्जी 34.10 दुई ठूला संख्याहरू हुन् जसलाई gost3410.pub_marshal() प्रयोग गरेर भण्डारण र प्रसारणको सहजताको लागि बाइट अनुक्रममा रूपान्तरण गर्न आवश्यक छ।

  JSON फाइल पढिसकेपछि, सार्वजनिक कुञ्जीहरू तदनुसार gost3410.pub_unmarshal() प्रयोग गरेर फिर्ता रूपान्तरण गर्न आवश्यक छ। हामीले सार्वजनिक कुञ्जीबाट ह्यासको रूपमा अन्तर्वार्ताकर्ताहरूको पहिचानकर्ताहरू प्राप्त गर्ने भएकोले, तिनीहरू तुरुन्तै अग्रिम गणना गर्न सकिन्छ र द्रुत खोजको लागि शब्दकोशमा राख्न सकिन्छ। Stribog-256 hash gost34112012256.GOST34112012256(), जसले ह्यास प्रकार्यहरूको hashlib इन्टरफेसलाई पूर्ण रूपमा सन्तुष्ट गर्दछ।

  सुरुवातकर्ता कोरुटिन कसरी परिवर्तन भएको छ? सबै कुरा ह्यान्डशेक योजना अनुसार छ: हामीले एउटा कुकी (१२८-बिट प्रशस्त छ), एउटा अल्पकालिक कुञ्जी जोडी ३४.१०, जुन 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-बिट नम्बर हो (urandom(8)), जसलाई gost3410_vko.ukm_unmarshal() को प्रयोग गरेर यसको बाइट प्रतिनिधित्वबाट deserialization आवश्यक छ। 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, KGB मा फेरि सिर्जना गरिएको र अझै पनि उच्चतम सुरक्षा थ्रेसहोल्डहरू मध्ये एक छ।

  Kuznechik लाई gost.3412.GOST3412Kuznechik(key) मा कल गरेर प्रारम्भ गरिएको छ र .encrypt()/.decrypt() विधिहरू 34.13 प्रकार्यहरूमा पास गर्नका लागि उपयुक्त भएको वस्तु फिर्ता गर्छ। MAC लाई निम्नानुसार गणना गरिन्छ: gost3413.mac(GOST3412Kuznechik(key)। encrypt, KUZNECHIK_BLOCKSIZE, ciphertext)। गणना गरिएको र प्राप्त भएको MAC तुलना गर्न, तपाईले बाइट स्ट्रिङको सामान्य तुलना (==) प्रयोग गर्न सक्नुहुन्न, किनकि यो अपरेशनले तुलनात्मक समय चुहावट गर्छ, जुन सामान्य अवस्थामा, घातक कमजोरीहरू निम्त्याउन सक्छ। BEAST 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, plaintext, iv)। इन्क्रिप्शन ब्लकको ठ्याक्कै आधा लम्बाइ भएको प्रारम्भिक भेक्टर निर्दिष्ट गर्न आवश्यक छ। यदि हाम्रो इन्क्रिप्शन कुञ्जी केवल एउटा सन्देश इन्क्रिप्ट गर्न प्रयोग गरिन्छ (धेरै ब्लकहरूबाट भए पनि), त्यसपछि यो शून्य प्रारम्भिक भेक्टर सेट गर्न सुरक्षित छ। ह्यान्डशेक सन्देशहरू इन्क्रिप्ट गर्न, हामी प्रत्येक पटक छुट्टै कुञ्जी प्रयोग गर्छौं।

  हस्ताक्षर प्रमाणीकरण gost3410.verify() मामूली छ: हामी अण्डाकार वक्र पार गर्छौं जुन भित्र हामीले काम गरिरहेका छौं (हामी यसलाई हाम्रो GOSTIM प्रोटोकलमा रेकर्ड गर्छौं), हस्ताक्षरकर्ताको सार्वजनिक कुञ्जी (यो दुईको टुपल हुनुपर्छ भनेर नबिर्सनुहोस्। ठूलो संख्या, र बाइट स्ट्रिङ होइन), 34.11/2012/XNUMX ह्यास र हस्ताक्षर आफै।

  अर्को, इनिसिएटरमा हामी ह्यान्डशेक २ मा ह्यान्डशेक सन्देश तयार गर्छौं र पठाउँछौं, प्रमाणीकरणको क्रममा हामीले गरेको समान कार्यहरू प्रदर्शन गर्दै, केवल सममित रूपमा: जाँच गर्नुको सट्टा हाम्रो कुञ्जीहरूमा हस्ताक्षर गर्ने, इत्यादि...

   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 coroutine ले अब सन्देशहरूलाई 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 coroutine द्वारा प्रशोधन गरिन्छ, जसले प्रमाणीकरण र डिक्रिप्शन ह्यान्डल गर्दछ:

  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, NCCP, GoVPN, GOSTIM पूर्ण रूपमा छ नि: शुल्क सफ्टवेयर, सर्तहरू अन्तर्गत वितरित GPLv3 +.

  सर्गेई Matveev, साइफरपंक, सदस्य SPO फाउन्डेसन, पाइथन/गो विकासकर्ता, प्रमुख विशेषज्ञ FSUE "STC "एटलस".

स्रोत: www.habr.com