GOSTIM: P2P F2F E2EE IM في ليلة واحدة مع تشفير GOST

بصفتي مطورًا لمكتبة PyGOST ( بدايات تشفير GOST في Python الخالص) ، غالبًا ما أحصل على أسئلة حول كيفية تنفيذ أبسط الرسائل الآمنة على ركبتي. يعتبر الكثيرون أن التشفير المطبق أمر بسيط إلى حد ما ، وستكون مكالمة. encrypt () إلى تشفير البلوك كافية لإرسالها بأمان عبر قناة اتصال. يعتقد البعض الآخر أن التشفير المطبق هو مصير عدد قليل ، ومن المقبول أن الشركات الغنية مثل Telegram مع أولمبياد الرياضيات لا تستطيع تطبيق بروتوكول آمن.

كل هذا دفعني إلى كتابة هذه المقالة لإظهار أن تنفيذ بروتوكولات التشفير والتراسل الفوري الآمن ليس مهمة صعبة. ومع ذلك ، فإن ابتكار بروتوكولات المصادقة والاتفاق الرئيسية لا يستحق كل هذا العناء.


سيتم كتابة المقال برسالة فورية مشفرة من نظير إلى نظير ، وصديق إلى صديق ، مشفرة من طرف إلى طرف مع مصادقة SIGMA-I وبروتوكول اتفاق المفتاح (بناءً على تطبيق IPsec IKE ) ، باستخدام خوارزميات تشفير GOST حصريًا مكتبة PyGOST و ترميز ASN.1 للرسائل مع مكتبة PyDERASN (التي كتبت عنها من قبل ). المتطلب السابق: يجب أن يكون الأمر بسيطًا للغاية بحيث يمكن كتابته من نقطة الصفر في إحدى الليالي (أو يوم العمل) ، وإلا فإنه لم يعد برنامجًا بسيطًا. من المحتمل أنه يحتوي على أخطاء وصعوبات غير ضرورية وأوجه قصور ، بالإضافة إلى أن هذا هو أول برنامج لي باستخدام مكتبة asyncio.

تصميم الدردشة

لتبدأ ، تحتاج إلى فهم كيف سيبدو IM لدينا. للبساطة ، فليكن شبكة من نظير إلى نظير ، دون أي اكتشاف للمشاركين. سنشير شخصيًا إلى العنوان: المنفذ الذي سيتم الاتصال به للتواصل مع المحاور.

أفهم أنه في الوقت الحالي ، يعد افتراض توفر الاتصال المباشر بين جهازي كمبيوتر تعسفيين أحد القيود المهمة على تطبيق الرسائل الفورية في الممارسة العملية. ولكن كلما زاد عدد المطورين الذين سينفذون جميع أنواع عكاز NAT-traversal ، كلما بقينا على الإنترنت IPv4 ، مع احتمال محبط للاتصال بين أجهزة الكمبيوتر التعسفية. حسنًا ، إلى أي مدى يمكنك تحمل نقص IPv6 في المنزل وفي العمل؟

سيكون لدينا شبكة من صديق إلى صديق: يجب أن تكون جميع المحاورين المحتملين معروفة مسبقًا. أولاً ، إنه يبسط كل شيء إلى حد كبير: قدم نفسه ، أو وجد أو لم يجد اسمًا / مفتاحًا ، أو غير متصل أو مستمر في العمل ، ومعرفة المحاور. ثانياً ، في الحالة العامة ، إنه آمن ويستبعد العديد من الهجمات.

ستكون واجهة المراسلة الفورية قريبة من الحلول الكلاسيكية للمشاريع غير الملموسة ، والتي أحبها حقًا لفلسفتها وفلسفتها في نظام Unix-way. يقوم برنامج IM لكل محاور بإنشاء دليل يحتوي على ثلاثة مآخذ للنطاق Unix:

• في - يتم تسجيل الرسائل المرسلة إلى المحاور فيها ؛
• الرسائل الخارجية الواردة من المحاور تتم قراءتها منه ؛
• الحالة - من خلال القراءة ، سنكتشف ما إذا كان المحاور متصل الآن ، وعنوان / منفذ الاتصال.

بالإضافة إلى ذلك ، يتم إنشاء مأخذ توصيل conn ، نكتب إلى أي منفذ مضيف ، نبدأ في الاتصال بمحاور بعيد.

 | - أليس
 |  | - في
 |  | - خارج
 |  `- الدولة
 | - بوب
 |  | - في
 |  | - خارج
 |  `- الدولة
 `- كون

يتيح لك هذا النهج إجراء تطبيقات مستقلة لنقل الرسائل الفورية وواجهة المستخدم ، لأنه لا يوجد صديق للذوق واللون ، فلن يرضي الجميع. باستخدام tmux و / أو multitail ، يمكنك الحصول على واجهة متعددة النوافذ مع تسليط الضوء على بناء الجملة. ومع rlwrap ، يمكنك الحصول على سلسلة متوافقة مع GNU Readline لإدخال الرسائل.

في الواقع ، تستخدم مشاريع suckless ملفات FIFO. شخصيا ، لم أستطع أن أفهم كيف أن العمل غير المتزامن مع الملفات بشكل تنافسي دون ركيزة مصنوعة يدويًا من سلاسل الرسائل المحددة (كنت أستخدم لغة Go لمثل هذه الأشياء لفترة طويلة). لذلك ، قررت أن أحصل على مآخذ المجال يونيكس. لسوء الحظ ، هذا يجعل من المستحيل القيام صدى 2001: 470: dead :: babe 6666> conn. لقد قمت بحل هذه المشكلة باستخدام socat : echo 2001: 470: dead :: babe 6666 | socat - UNIX-CONNECT: conn، socat READLINE UNIX-CONNECT: alice / in.

بروتوكول غير آمن الأولي

يستخدم TCP كوسيلة نقل: إنه يضمن التسليم وترتيبه. يضمن UDP لا هذا ولا ذاك (والذي سيكون مفيدًا عند تطبيق التشفير) ، ودعم SCTP في Python خارج الصندوق.

لسوء الحظ ، ليس لدى TCP مفهوم للرسالة ، ولكن فقط دفق من البايت. لذلك ، من الضروري التوصل إلى تنسيق للرسائل بحيث يمكن مشاركتها فيما بينها في هذا الدفق. يمكننا أن نوافق على استخدام حرف تغذية السطر. بالنسبة للمبتدئين ، من المناسب ، عندما نبدأ بتشفير رسائلنا ، قد يظهر هذا الرمز في أي مكان في النص المشفر. لذلك ، تعتبر البروتوكولات شائعة على الشبكات ، حيث ترسل أولاً طول الرسالة بالبايت. على سبيل المثال ، في Python ، يوجد خارج الصندوق xdrlib ، والذي يسمح لك بالعمل بتنسيق XDR مماثل.

لن نعمل بشكل صحيح وكفء مع قراءة TCP - نحن نبسط الشفرة. نقرأ البيانات من مأخذ التوصيل في حلقة لا نهائية حتى نقوم بفك تشفير الرسالة كاملة. يمكنك أيضًا استخدام JSON مع XML كتنسيق لهذا النهج. ولكن عند إضافة التشفير ، سيتعين توقيع البيانات والمصادقة عليها - وهذا سيتطلب تمثيلًا متطابقًا بايت لكل كائنات ، والتي لا يوفرها JSON / XML (قد تختلف عمليات التفريغ).

XDR مناسبة لمثل هذه المهمة ، ومع ذلك ، اخترت ASN.1 مع DER ترميز ومكتبة PyDERASN ، حيث سيكون لدينا كائنات عالية المستوى في متناول اليد ، والتي غالبا ما تكون أكثر ملاءمة للعمل. بخلاف bencode أو 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 (التي يتم فيها نقل اسم المحاور). الآن يبدو الأمر معقدًا ، لكنه تحدٍ للمستقبل.

      ┌─────┐ ┌─────┐
      eerPeerA│ │PeerB│
      └──┬──┘ └──┬──┘
         sgMsgHandshake (IdA) │
         │───────────────── >> │
         │ │
         sgMsgHandshake (IdB) │
         │ <─────────────────│
         │ │
         sg MsgText () │
         │───────────────── >> │
         │ │
         sg MsgText () │
         │ <─────────────────│
         │ │

الدردشة دون التشفير

كما قلت ، سيتم استخدام مكتبة المزامنة لجميع العمليات مع مآخذ. أعلن ما نتوقعه عند الإطلاق:

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

حدد اسمك الخاص (- اسمك أليس). تسرد الفاصلة جميع المحاورين المتوقعين (- أسماءهم bob ، eve). لكل من المحاورين ، يتم إنشاء دليل مع مآخذ يونكس ، وكذلك coroutine لكل في ، خارج ، الدولة:

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

عند كتابة عنوان إلى مقبس conn ، يتم إطلاق وظيفة "البادئ" الخاصة بالاتصال:

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

نتحقق من أن اسم الشخص الذي نتحدث معه معروف لنا. إذا لم يكن كذلك ، ثم قطع الاتصال. نتحقق مما إذا كنا قد أنشأنا بالفعل اتصالًا معه (أعطى المحاور الأمر مرة أخرى للاتصال بنا) وإغلاقه. يتم وضع سلاسل Python مع نص الرسالة في قائمة انتظار IN_QUEUES ، ولكن هناك قيمة خاصة بلا ، والتي تشير إلى 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 ونوقف تشغيل corgine msg_sender (عن طريق إرسال بلا إلى قائمة انتظار OUT_QUEUES).

  174 buf = b"" 175 # Wait for test messages {{{ 176 while True: 177 data = await reader.read(MaxMsgLen) 178 if data == b"": 179 break 180 buf += data 181 if len(buf) > MaxMsgLen: 182 logging.warning("%s: max buffer size exceeded", _id) 183 break 184 try: 185 msg, tail = Msg().decode(buf) 186 except ASN1Error: 187 continue 188 buf = tail 189 if msg.choice != "text": 190 logging.warning("%s: unexpected %s message", _id, msg.choice) 191 break 192 try: 193 await msg_receiver(msg.value, peer_name) 194 except ValueError as err: 195 logging.warning("%s: %s", err) 196 break 197 # }}} 198 logging.info("%s: disconnecting: %s", _id, peer_name) 199 IN_QUEUES[peer_name].put(None) 200 writer.close() 66 async def msg_receiver(msg_text: MsgText, peer_name: str) -> None: 67 text = str(msg_text["text"]) 68 logging.info("%s: received %d characters message", peer_name, len(text)) 69 await OUT_QUEUES[peer_name].put(text) 

دعنا نعود إلى الرمز الرئيسي. بعد إنشاء جميع coroutines ، في وقت بدء البرنامج ، بدأنا خادم TCP. لكل اتصال المنشأة ، وقال انه يخلق coroutine المستجيب.

 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 ، فإن مصدرها هو بروتوكولات STS و ISO / IEC IS 9798-3 و SIGMA (SIGn-and-MAc) - بسيطة بما يكفي للتنفيذ في مساء واحد.

كيف SIGMA ، باعتبارها الحلقة الأخيرة في تطوير بروتوكولات STS / ISO ، جيدة؟ يرضي جميع متطلباتنا (بما في ذلك "إخفاء" معرفات المتحاورين) ، وليس لديه مشاكل تشفير معروفة. إنه بسيط - إزالة عنصر واحد على الأقل من رسالة البروتوكول سيؤدي إلى انعدام الأمن.

دعنا ننتقل من أبسط بروتوكول محلي إلى SIGMA. إن العملية الأكثر أهمية التي نهتم بها هي مطابقة المفاتيح : وظيفة في الناتج يحصل كلا المشاركين فيها على نفس القيمة التي يمكن استخدامها كمفتاح متماثل. دون الخوض في التفاصيل: يقوم كل طرف بإنشاء زوج رئيسي (يستخدم فقط في نفس الجلسة) زوج مفاتيح (مفاتيح عامة وخاصة) ، ويتبادل المفاتيح العامة ، ويدعو إلى وظيفة المطابقة ، التي يرسلون إليها مفتاحهم الخاص والمفتاح العام للمحاور.

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

يمكن لأي شخص التدخل في الوسط واستبدال المفاتيح العامة بمفاتيح خاصة بهم - في هذا البروتوكول لا يوجد مصادقة للمحاورين. إضافة توقيع مع مفاتيح طويلة العمر.

 ┌─────┐ ┌─────┐
 eerPeerA│ │PeerB│
 └──┬──┘ └──┬──┘
    │IdA ، PubA ، علامة (SignPrvA ، (PubA)) │ ╔═══════════════════════╗
    │ ─ ─ ─ ─ ign ign ign ign ign ign ign ─ ─ ─ ─ ─ ─ ─ ─ ─ P P P Sign Sign Sign Sign Sign Sign Sign Sign Sign Sign Sign Sign Sign Sign Sign Sign Sign Sign Sign Sign Sign Sign load load load load load load load load load load load load load load load load load load load load load load load load load load load
    r │ ║PrvA ، PubA = DHgen () ║
    │ │ ╚══ ═ ═ ═ ═ ╝ ╝ ═ ╝ ╝ ╝ ╝ ╝ ╝
    │IdB ، PubB ، علامة (SignPrvB ، (PubB)) │ ╔═══════════════════════╗
    SignPrvB ، SignPubB = load () ║
    r │ ║PrvB ، PubB = DHgen () ║
    │ │ ╚══ ═ ═ ═ ═ ╝ ╝ ═ ╝ ╝ ╝ ╝ ╝ ╝
    ────┐ ╔═════════════════════│ │
        تحقق من (SignPubB ، ...) ║ │
    <───┘ ║Key = DH (PrvA، PubB) ║ │
    │ ╚═════════════════════╝ │
    │ │

لن يعمل هذا التوقيع ، لأنه غير مرتبط بجلسة محددة. هذه الرسائل مناسبة أيضًا للجلسات مع المشاركين الآخرين. يجب الاشتراك في السياق بأكمله. هذا يفرض أيضًا إضافة رسالة أخرى من A.

بالإضافة إلى ذلك ، من الضروري إضافة المعرّف الخاص بك كتوقيع ، لأنه ، وإلا ، يمكننا استبدال IdXXX وإعادة توقيع الرسالة بمفتاح محاور معروف آخر. لمنع هجمات الانعكاس ، من الضروري أن تكون العناصر الموجودة تحت التوقيع في أماكن محددة بوضوح بمعناها: إذا كانت علامات A (PubA ، PubB) ، فيجب على B التوقيع (PubB ، PubA). يشير هذا أيضًا إلى أهمية اختيار بنية وشكل البيانات المتسلسلة. على سبيل المثال ، يتم فرز المجموعات في ترميز ASN.1 DER: SET OF (PubA ، PubB) ستكون مطابقة لـ SET OF (PubB ، PubA).

 ┌─────┐ ┌─────┐
 eerPeerA│ │PeerB│
 └──┬──┘ └──┬──┘
    │ IdA ، PubA │ ╔══════════════════════════
    ign ─ ─ ─ ─ ─ ─ ign ign ign ign ign ign ign ign ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ SignPubA = load () ║
    r │ ║PrvA ، PubA = DHgen () ║
    │ │ ╚══ ═ ═ ═ ═ ╝ ╝ ═ ╝ ╝ ╝ ╝ ╝ ╝
    │IdB ، PubB ، sign (SignPrvB، (IdB، PubA، PubB)) │ ╔═════════════════════╗
    │ SignPrvB ، │ SignPubB = load () ║
    r │ ║PrvB ، PubB = DHgen () ║
    │ │ ╚══ ═ ═ ═ ═ ╝ ╝ ═ ╝ ╝ ╝ ╝ ╝ ╝
    │ sign (SignPrvA، (IdA، PubB، PubA)) │ ╔═══════════════════╗
    │ ─ ─ ─ ─ ─> ify ify ify ify ify ify ify ify ify ify ify ify ify ify ify ify ify ify ify SignPubB ، ...) ║
    │ │ ║Key = DH (PrvA، PubB) ║
    ╝ │ ╚══ ═ ═ ═ ╝ ╝ ╝ ═ ╝ ╝ ╝
    │ │

ومع ذلك ، لم نثبت بعد أننا طورنا نفس المفتاح المشترك لهذه الجلسة. من حيث المبدأ ، يمكنك الاستغناء عن هذه الخطوة - سيكون اتصال النقل الأول غير صالح ، لكننا نريد أنه عند اكتمال المصافحة ، سنكون متأكدين من أن كل شيء تم الاتفاق عليه حقًا. في الوقت الحالي ، لدينا بين أيدينا بروتوكول ISO / IEC IS 9798-3.

يمكننا التوقيع على المفتاح نفسه. هذا أمر خطير ، لأنه من المحتمل أن يكون هناك تسرب في خوارزمية التوقيع المستخدمة (اسمح بت لكل توقيع ، ولكن لا يزال تسرب). يمكنك تسجيل علامة تجزئة من المفتاح الذي تم إنشاؤه ، ولكن حتى تسرب علامة تجزئة من المفتاح الذي تم إنشاؤه يمكن أن يكون ذا قيمة في هجوم القوة الغاشمة على وظيفة التوليد. تستخدم SIGMA وظيفة MAC تقوم بمصادقة معرف المرسل.

 ┌─────┐ ┌─────┐
 eerPeerA│ │PeerB│
 └──┬──┘ └──┬──┘
    │ IdA ، PubA │ ╔══════════════════════════
    │ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ │ │ ─ │ │ │ │ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ > ign ignSignPrvA ، SignPubA = load () ║
    r │ ║PrvA ، PubA = DHgen () ║
    │ │ ╚══ ═ ═ ═ ═ ╝ ╝ ═ ╝ ╝ ╝ ╝ ╝ ╝
    │IdB ، PubB ، علامة (SignPrvB ، (PubA ، PubB)) ، MAC (IdB) │ ╔═════════════════╗
    │ <─── ─ ─ ─ ─ ─ │ │ │ │ │ │ ign ignSignPrvB ، SignPubB = load () ║
    r │ ║PrvB ، PubB = DHgen () ║
    │ │ ╚══ ═ ═ ═ ═ ╝ ╝ ═ ╝ ╝ ╝ ╝ ╝ ╝
    ╗ │ ╔══ ═ ═ ═ ╗ ╗ ╗ ═ ╗ ╗ ╗
    │ sign (SignPrvA، (PubB، PubA))، MAC (IdA) │ ║Key = DH (PrvA، PubB) ║
    │ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ │ │ ─ ─ │ │ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ > ║ ║ التحقق (المفتاح ، IdB) ║
    ify │ ║ تحقق (SignPubB ، ...) ║
    ╝ │ ╚══ ═ ═ ═ ╝ ╝ ╝ ═ ╝ ╝
    │ │

كتحسين ، قد يرغب البعض في إعادة استخدام المفاتيح المؤقتة الخاصة بهم (والتي ، بالطبع ، أمر محزن بالنسبة لـ PFS). على سبيل المثال ، أنشأنا زوجًا رئيسيًا ، حاولنا الاتصال ، لكن TCP لم يكن متاحًا أو مقطوعًا في مكان ما في منتصف البروتوكول. إنه لأمر مؤسف أن تنفق موارد الكون والمعالج التي تنفق على زوج جديد. لذلك ، نقدم ما يسمى ملف تعريف الارتباط - قيمة عشوائية زائفة من شأنها أن تحمي من هجمات الإعادة العرضية المحتملة عند إعادة استخدام المفاتيح العامة المؤقتة. نظرًا للربط بين ملف تعريف الارتباط والمفتاح العمومي المؤقت ، يمكن إزالة المفتاح العمومي للطرف المقابل من التوقيع باعتباره غير ضروري.

 ┌─────┐ ┌─────┐
 eerPeerA│ │PeerB│
 └──┬──┘ └──┬──┘
    │ IdA ، PubA ، CookieA │ ╔═════════════════════════
    │ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ │ │ ─ │ │ │ │ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ──────────────────── >> │ │ SignPrvA، SignPubA = load () ║
    r │ ║PrvA ، PubA = DHgen () ║
    │ │ ╚══ ═ ═ ═ ═ ╝ ╝ ═ ╝ ╝ ╝ ╝ ╝ ╝
    │IdB، PubB، CookieB، sign (SignPrvB، (CookieA، CookieB، PubB))، MAC (IdB) │ ╔ ═ ═ ═ ╔ ╔ ═══╗
    │ <─── ─ ─ ─ ─ ─ │ │ │ │ │ │ ign ignSignPrvB ، SignPubB = load () ║
    r │ ║PrvB ، PubB = DHgen () ║
    │ │ ╚══ ═ ═ ═ ═ ╝ ╝ ═ ╝ ╝ ╝ ╝ ╝ ╝
    ╗ │ ╔══ ═ ═ ═ ╗ ╗ ╗ ═ ╗ ╗
    │ sign (SignPrvA ، (CookieB ، CookieA ، PubA)) ، MAC (IdA) DH Key = DH (PrvA، PubB) ║
    │ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ │ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ify ify ify ify ify ify ify ify ify ify ify Verify (Key، IdB) ║
    ify │ ║ تحقق (SignPubB ، ...) ║
    ╝ │ ╚══ ═ ═ ═ ╝ ╝ ╝ ═ ╝ ╝ ╝
    │ │

أخيرًا ، نرغب في الحصول على خصوصية مُعرّفات المحاور لدينا من مراقب سلبي. للقيام بذلك ، تقترح SIGMA أولاً تبادل مفاتيح سريعة الزوال ، والعمل على مفتاح شائع لمصادقة رسائل المصادقة. يصف SIGMA خيارين:

• SIGMA-I - يحمي البادئ من الهجمات النشطة ، والمستجيب من الهجمات السلبية: البادئ يصادق المستجيب وإذا كان هناك شيء غير مناسب ، فإنه لا يعطي هويته. يعطي المدعى عليه هويته إذا بدأت بروتوكول نشط معه. المراقب السلبي لن يعرف شيئًا ؛
  SIGMA-R - يحمي المستجيب من الهجمات النشطة ، البادئ من المبني للمجهول. كل شيء عكس ذلك تمامًا ، ولكن في هذا البروتوكول يتم بالفعل إرسال أربع رسائل مصافحة.
  
  
  نختار SIGMA-I أكثر شبهاً بما نتوقعه من الأشياء المعتادة من الخادم-العميل: فقط الخادم المصادق عليه يتعرف على العميل ، ويعرف الجميع الخادم على أي حال. بالإضافة إلى أنه من الأسهل تنفيذه بسبب عدد رسائل المصافحة أقل. كل ما نضيفه إلى البروتوكول هو تشفير جزء الرسالة ونقل المعرف A إلى الجزء المشفر من الرسالة الأخيرة:
  
  

   ┌─────┐ ┌─────┐
   eerPeerA│ │PeerB│
   └──┬──┘ └──┬──┘
      │ PubA ، CookieA │ ╔══════════════════════════╗
      │ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ │ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ign ign ign ign ign ign ign ign ign ign ،، ،، ،، ،، ،، ،، ،، ،، ،، ،، ،، ،، ،، ،، ،، ،، ،، ،، ،، ،، ،، ،، Sign Sign Sign Sign Sign Sign Sign Sign Sign Sign Sign Sign Sign Sign Sign Sign Sign Sign Sign Sign Sign Sign ((((((((((((
      r │ ║PrvA ، PubA = DHgen () ║
     │ │ ╚═══════════════════════════╝
     │PubB, CookieB, Enc((IdB, sign(SignPrvB, (CookieA, CookieB, PubB)), MAC(IdB))) │ ╔═══════════════════════════╗
     │<─────────────────────────────────────────────────────────────────────────────│ ║SignPrvB, SignPubB = load()║
     │ │ ║PrvB, PubB = DHgen() ║
     │ │ ╚═══════════════════════════╝
     │ │ ╔═════════════════════╗
     │ Enc((IdA, sign(SignPrvA, (CookieB, CookieA, PubA)), MAC(IdA))) │ ║Key = DH(PrvA, PubB) ║
     │─────────────────────────────────────────────────────────────────────────────>│ ║verify(Key, IdB) ║
     │ │ ║verify(SignPubB, ...)║
     │ │ ╚═════════════════════╝
     │ │
  

  
  
  
  • 34.10-2012 256- .
  • 34.10-2012 VKO.
  • MAC CMAC. , 34.13-2015. — (34.12-2015).
  • . -256 (34.11-2012 256 ).
  
  
  . . : , , (MAC) , . , , . , , ? . , KDF (key derivation function). , - : HKDF , . , Python , hkdf . HKDF HMAC , , , -. Python Wikipedia . 34.10-2012, - -256. , :
  
  

   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 — , (to be signed). HandshakeTBE — , (to be encrypted). ukm MsgHandshake1. 34.10 VKO, , UKM (user keying material) — .
  
  
  
  , ( , , ).
  
  , - . JSON :
  
  

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

  
  our — , . their — . 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(). , . -256 gost34112012256.GOST34112012256(), hashlib -.
  
  ? , : cookie (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() 

  
  
  • Msg ;
  • handshake1;
  • ;
  • 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(). VKO 34.10-2012 256- gost3410_vko.kek_34102012256() (KEK — key encryption key).
  
  256- . HKDF . GOST34112012256 hashlib , Hkdf . ( Hkdf) , - . kdf.expand() 256-, .
  
  TBE TBS :
  
  
  • MAC ;
  • ;
  • TBE ;
  • ;
  • MAC ;
  • TBS , cookie . .
  
  

    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 34.12-2015. , MAC-. PyGOST gost3413.mac(). ( ), , , . hardcode- ? 34.12-2015 128- , 64- — 28147-89, .
  
  gost.3412.GOST3412Kuznechik(key) .encrypt()/.decrypt() , 34.13 . MAC : gost3413.mac(GOST3412Kuznechik(key).encrypt, KUZNECHIK_BLOCKSIZE, ciphertext). MAC- (==) , , , , BEAST TLS. Python 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). , . ( ), . handshake .
  
  gost3410.verify() : ( GOSTIM ), ( , , ), 34.11-2012 .
  
  , handshake2 , , : , .…
  
  

    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-. nonce, . .
  
  

   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 , NNCP , GoVPN , GOSTIM , GPLv3+ .
  
  , , , Python/Go-, « „“ .