GOSTIM: GOST ক্রিপ্টোগ্রাফি সহ এক সন্ধ্যায় P2P F2F E2EE IM

একজন ডেভেলপার হচ্ছে পাইগোস্ট লাইব্রেরি (বিশুদ্ধ পাইথনে GOST ক্রিপ্টোগ্রাফিক আদিম), আমি প্রায়শই হাঁটুতে সবচেয়ে সহজ নিরাপদ মেসেজিং কীভাবে বাস্তবায়ন করা যায় সে সম্পর্কে প্রশ্ন পাই। অনেক লোক প্রয়োগকৃত ক্রিপ্টোগ্রাফিকে বেশ সহজ বলে মনে করেন এবং একটি ব্লক সাইফারে .encrypt() কল করা একটি যোগাযোগ চ্যানেলে নিরাপদে পাঠানোর জন্য যথেষ্ট হবে। অন্যরা বিশ্বাস করে যে প্রয়োগকৃত ক্রিপ্টোগ্রাফি হল অল্প কয়েকজনের নিয়তি, এবং এটি গ্রহণযোগ্য যে টেলিগ্রামের মতো ধনী কোম্পানি অলিম্পিয়াড-গণিতবিদদের সাথে বাস্তবায়ন করতে পারে না নিরাপদ প্রোটোকল।

এই সব আমাকে এই নিবন্ধটি লেখার জন্য প্ররোচিত করেছে যে ক্রিপ্টোগ্রাফিক প্রোটোকল এবং সুরক্ষিত IM বাস্তবায়ন করা এত কঠিন কাজ নয়। যাইহোক, এটি আপনার নিজস্ব প্রমাণীকরণ এবং মূল চুক্তি প্রোটোকল উদ্ভাবনের মূল্য নয়।

প্রবন্ধ লিখবেন পিয়ার টু পিয়ার, বন্ধু থেকে বন্ধু, এন্ড-টু-এন্ড এনক্রিপ্ট করা সাথে তাত্ক্ষণিক বার্তাবাহক সিগমা-আই প্রমাণীকরণ এবং মূল চুক্তি প্রোটোকল (যার ভিত্তিতে এটি বাস্তবায়িত হয় আইপিসেক আইকেই), একচেটিয়াভাবে GOST ক্রিপ্টোগ্রাফিক অ্যালগরিদম PyGOST লাইব্রেরি এবং ASN.1 বার্তা এনকোডিং লাইব্রেরি ব্যবহার করে পাইডারাসন (যা সম্পর্কে আমি ইতিমধ্যেই আগে লিখেছেন) একটি পূর্বশর্ত: এটি এত সহজ হতে হবে যে এটি একটি সন্ধ্যায় (বা কাজের দিন) স্ক্র্যাচ থেকে লেখা যেতে পারে, অন্যথায় এটি আর একটি সাধারণ প্রোগ্রাম নয়। এটিতে সম্ভবত ত্রুটি, অপ্রয়োজনীয় জটিলতা, ত্রুটি রয়েছে, প্লাস এটি অ্যাসিনসিও লাইব্রেরি ব্যবহার করে আমার প্রথম প্রোগ্রাম।

আইএম ডিজাইন

প্রথমত, আমাদের বুঝতে হবে আমাদের 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 করা অসম্ভব করে তোলে। আমি ব্যবহার করে এই সমস্যার সমাধান করেছি socat: echo 2001:470:dead::bebe 6666 | socat - UNIX-CONNECT:conn, socat READLINE UNIX-CONNECT:alice/in.

মূল অনিরাপদ প্রোটোকল

TCP পরিবহন হিসাবে ব্যবহৃত হয়: এটি ডেলিভারি এবং এর অর্ডার নিশ্চিত করে। UDP গ্যারান্টি দেয় না (যা ক্রিপ্টোগ্রাফি ব্যবহার করা হলে কাজে লাগবে), কিন্তু সমর্থন করে এসসিটিপি পাইথন বাক্সের বাইরে আসে না।

দুর্ভাগ্যবশত, টিসিপিতে একটি বার্তার কোন ধারণা নেই, শুধুমাত্র বাইটের একটি প্রবাহ। অতএব, বার্তাগুলির জন্য একটি বিন্যাস নিয়ে আসা প্রয়োজন যাতে সেগুলি এই থ্রেডে নিজেদের মধ্যে ভাগ করা যায়৷ আমরা লাইন ফিড অক্ষর ব্যবহার করতে সম্মত হতে পারি। এটি শুরু করার জন্য ঠিক আছে, কিন্তু একবার আমরা আমাদের বার্তাগুলি এনক্রিপ্ট করা শুরু করলে, এই অক্ষরটি সাইফারটেক্সটের যে কোনও জায়গায় উপস্থিত হতে পারে। নেটওয়ার্কগুলিতে, তাই, জনপ্রিয় প্রোটোকলগুলি হল যেগুলি প্রথমে বার্তার দৈর্ঘ্য বাইটগুলিতে পাঠায়। উদাহরণস্বরূপ, পাইথনের বাক্সের বাইরে রয়েছে xdrlib, যা আপনাকে একই বিন্যাসের সাথে কাজ করতে দেয় XDR.

আমরা TCP পড়ার সাথে সঠিকভাবে এবং দক্ষতার সাথে কাজ করব না - আমরা কোডটি সরল করব। আমরা সম্পূর্ণ বার্তা ডিকোড না করা পর্যন্ত আমরা একটি অন্তহীন লুপে সকেট থেকে ডেটা পড়ি। XML সহ JSON এই পদ্ধতির জন্য একটি বিন্যাস হিসাবেও ব্যবহার করা যেতে পারে। কিন্তু যখন ক্রিপ্টোগ্রাফি যোগ করা হয়, তখন ডেটা সাইন ইন এবং প্রমাণীকরণ করতে হবে - এবং এর জন্য বস্তুর বাইট-ফর-বাইট অভিন্ন উপস্থাপনা প্রয়োজন, যা JSON/XML প্রদান করে না (ডাম্পের ফলাফল পরিবর্তিত হতে পারে)।

XDR এই কাজের জন্য উপযুক্ত, তবে আমি DER এনকোডিং সহ ASN.1 নির্বাচন করি এবং পাইডারাসন লাইব্রেরি, যেহেতু আমাদের হাতে উচ্চ-স্তরের বস্তু থাকবে যার সাথে কাজ করা প্রায়শই আরও আনন্দদায়ক এবং সুবিধাজনক। স্কিমলেস থেকে ভিন্ন বেনকোড, মেসেজপ্যাক বা সিবিওআর, 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 হ্যান্ডশেক বার্তা (যাতে কথোপকথনের নাম রয়েছে)। এখন এটা overcomplicated দেখায়, কিন্তু এটি ভবিষ্যতের জন্য একটি ভিত্তি.

     ┌─────┐ ┌─────┐ │PeerA│ │PeerB│ └──┬┘──┘ ── আইডিএ) │ │───────── ─────│───>│ │ │ │MsgHandshake(IdB) │ │<─────│ │ │ MsgText() │ │──── MsgText() │ │ │

ক্রিপ্টোগ্রাফি ছাড়া IM

আমি আগেই বলেছি, অ্যাসিনসিও লাইব্রেরি সমস্ত সকেট অপারেশনের জন্য ব্যবহার করা হবে। লঞ্চের সময় আমরা কী আশা করি তা ঘোষণা করা যাক:

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 এর সামান্য সম্পর্ক নেই)। তবে আমরা এটি বিবেচনা করি না কারণ এটি অতিরিক্ত জটিল।
• IP সেকে с Ike — গুরুতর ক্রিপ্টোগ্রাফিক সমস্যা নেই, যদিও সেগুলিও সহজ নয়। আপনি যদি IKEv1 এবং IKEv2 সম্পর্কে পড়েন তবে তাদের উত্স এসটিএস, ISO/IEC IS 9798-3 এবং SIGMA (SIGn-and-MAc) প্রোটোকল - এক সন্ধ্যায় প্রয়োগ করা যথেষ্ট সহজ।

STS/ISO প্রোটোকলের বিকাশের সর্বশেষ লিঙ্ক হিসাবে SIGMA সম্পর্কে কী ভাল? এটি আমাদের সমস্ত প্রয়োজনীয়তা পূরণ করে ("লুকানোর" কথোপকথন শনাক্তকারী সহ) এবং কোনও পরিচিত ক্রিপ্টোগ্রাফিক সমস্যা নেই৷ এটি সংক্ষিপ্ত - প্রোটোকল বার্তা থেকে অন্তত একটি উপাদান অপসারণ করা তার নিরাপত্তাহীনতার দিকে পরিচালিত করবে।

চলুন সিগমা-তে সবচেয়ে সহজ গৃহপালিত প্রোটোকল থেকে যাই। আমরা আগ্রহী সবচেয়ে মৌলিক অপারেশন হয় মূল চুক্তি: একটি ফাংশন যা উভয় অংশগ্রহণকারীকে একই মান আউটপুট করে, যা একটি সিমেট্রিক কী হিসাবে ব্যবহার করা যেতে পারে। বিশদ বিবরণে না গিয়ে: প্রতিটি পক্ষ একটি ক্ষণস্থায়ী (শুধুমাত্র একটি সেশনের মধ্যে ব্যবহৃত) কী জোড়া (সর্বজনীন এবং ব্যক্তিগত কী) তৈরি করে, পাবলিক কীগুলি বিনিময় করে, চুক্তি ফাংশনকে কল করে, যে ইনপুটটিতে তারা তাদের ব্যক্তিগত কী এবং জনসাধারণকে পাস করে। কথোপকথনের চাবিকাঠি।

┌─────┐ ┌─────┐ │পিরআ│ │পিরবি│ └──┬─ │ ╔═══════════ - ═ ═════════ ═══════════╝ │ IdB, PubB │ ╔══════════════════════════ │<───────── ──────│ ║PrvB, PubB = DHgen()║ │ │ ╚═══════════════════════════════ ───┐ ╔════ ═══╧════════════╗ │ ║কী = DH(PrvA, PubB)║ <───┘║ <───┘════════════════════ ═══════ ════╝ │ │ │ │

যে কেউ মাঝখানে ঝাঁপিয়ে পড়তে পারে এবং তাদের নিজস্ব কী দিয়ে পাবলিক কী প্রতিস্থাপন করতে পারে - এই প্রোটোকলটিতে ইন্টারলোকিউটারদের কোনও প্রমাণীকরণ নেই। চলুন দীর্ঘজীবী কী সহ একটি স্বাক্ষর যোগ করি।

┌────│, Py চিহ্ন (সাইন প্রভা, (PubA)) │ ╔═ সাইন 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) এর অনুরূপ হবে৷

┌─────┐ ┌─────┐ │পিরআ│ │পিরবি│ └──┬─ │ ╔═══════════ ═════════════════╗ │─────────────────────── ────────── ─────────────>│ ║SignPrvA, SignPubA = load()║ │ │ ║PrvA, PubA = DHgen╂ ═ ─ ─ ─ ═ ════════ ═══════════════╝ │IdB, PubB, চিহ্ন(SignPrvB, (IdB, PubA, PubB)) │ ════════════ ═════ ════════════╗ │<──────────────────────────── ────────── ─────────│ ║SignPrvB, SignPubB = load()║ │ │ ║PrvB, PubB = DHgen() ║ │ │ ═ ═ ═ ═ ═ ═ ═ ═ ═ ═════════ ══════════╝ │ চিহ্ন(SignPrvA, (IdA, PubB, PubA)) │ ╔═════════════════════ ════╗ │─ ─────────────────────────────────── ───>│ ║যাচাই করুন(সাইনপাববি, ...) ║ │ │ ║key = dh (prva, PUBB) ║ │ │ │

যাইহোক, আমরা এখনও "প্রমাণ" করতে পারিনি যে আমরা এই সেশনের জন্য একই ভাগ করা কী তৈরি করেছি৷ নীতিগতভাবে, আমরা এই পদক্ষেপটি ছাড়াই করতে পারি - প্রথম পরিবহন সংযোগটি অবৈধ হবে, তবে আমরা চাই যে হ্যান্ডশেক সম্পন্ন হলে, আমরা নিশ্চিত হব যে সবকিছু সত্যিই সম্মত হয়েছে। এই মুহূর্তে আমাদের হাতে ISO/IEC IS 9798-3 প্রোটোকল আছে।

আমরা উৎপন্ন কী নিজেই স্বাক্ষর করতে পারে. এটি বিপজ্জনক, কারণ এটি সম্ভব যে ব্যবহৃত স্বাক্ষর অ্যালগরিদমে লিক থাকতে পারে (যদিও বিট-প্রতি-স্বাক্ষর, কিন্তু এখনও লিক হয়)। ডেরিভেশন কী-এর একটি হ্যাশ সাইন করা সম্ভব, কিন্তু ডেরিভেটেড কী-এর হ্যাশ লিক করাও ডেরিভেশন ফাংশনের উপর ব্রুট-ফোর্স আক্রমণে মূল্যবান হতে পারে। SIGMA একটি MAC ফাংশন ব্যবহার করে যা প্রেরকের আইডি প্রমাণীকরণ করে।

┌─────┐ ┌─────┐ │পিরআ│ │পিরবি│ └──┬─ │ ╔═══════════ ═════════════════╗ │─────────────────────── ────────── * ╚ ═══════ ═- ═══ │<───────────────── ────────────────── ────────── ─│ ║SignPrvB, SignPubB = load()║ │ │ ║PrvB, PubB = DHgen() ║ │ │ ╚═══════════════════════ ══════════ * │ ║কী = DH( PrvA, PubB) ║ │─────────────────────────────────────── ────────── ─────>│ ║যাচাই করুন(কী, আইডিবি) ║ │ │ ║যাচাই করুন(সাইনপাববি, ...)║ │ │ ╚════════════════════════ ═════ ═╝ │ │

একটি অপ্টিমাইজেশান হিসাবে, কেউ কেউ তাদের ক্ষণস্থায়ী কীগুলি পুনরায় ব্যবহার করতে চাইতে পারে (যা অবশ্যই PFS এর জন্য দুর্ভাগ্যজনক)। উদাহরণস্বরূপ, আমরা একটি কী জোড়া তৈরি করেছি, সংযোগ করার চেষ্টা করেছি, কিন্তু TCP উপলব্ধ ছিল না বা প্রোটোকলের মাঝখানে কোথাও বিঘ্নিত হয়েছিল। একটি নতুন জুড়িতে নষ্ট এনট্রপি এবং প্রসেসর সম্পদ নষ্ট করা লজ্জাজনক। অতএব, আমরা তথাকথিত কুকি প্রবর্তন করব - একটি ছদ্ম-র্যান্ডম মান যা ক্ষণস্থায়ী পাবলিক কীগুলি পুনরায় ব্যবহার করার সময় সম্ভাব্য র্যান্ডম রিপ্লে আক্রমণ থেকে রক্ষা করবে। কুকি এবং ক্ষণস্থায়ী পাবলিক কী-এর মধ্যে আবদ্ধতার কারণে, বিপরীত পক্ষের পাবলিক কী অপ্রয়োজনীয় হিসাবে স্বাক্ষর থেকে সরানো যেতে পারে।

┌─────┐ ┌─────┐ │PeerA│ │PeerB│ └──┬┘I কুকিএ │ ╔════════ ═════└═════════════╗ │────└────────── ────────── ─────────────────────────────────── ─>│ ║SignPrvA, SignPubA = লোড( )║ │ │ ║PrvA, PubA = DHgen() ║ │ │ ╚══════════════════════════════ ══╝ │IdB, PubB, কুকিবি , সাইন(সাইনPrvB, (CookieA, CookieB, PubB)), MAC(IdB) │ ╔════════════════════════════ ═ ╗ │< ─────────────────────────────────── ────────── ────────────────────│ ║SignPrvB, SignPubB = load()║ │ │ PvB()║ │ │ PvB, │ ╚══════ ══════════════════════╝ │ │ ╔═══════════ ═══════╗ │ চিহ্ন( SignPrvA, (CookieB, CookieA, PubA)), MAC(IdA) │ ║কী = DH(PrvA, PubB) ║ │──────────────────────────────── ─ ── ─────────────────────────────────── ───────>│ ║ যাচাই করুন(কী, আইডিবি) ║ │ │ ║ যাচাই করুন(সাইনপাববি, ...)║ │ │ ╚══════════════════════════════ │ │

অবশেষে, আমরা একটি প্যাসিভ পর্যবেক্ষকের কাছ থেকে আমাদের কথোপকথন অংশীদারদের গোপনীয়তা পেতে চাই। এটি করার জন্য, সিগমা প্রথমে ক্ষণস্থায়ী কীগুলি বিনিময় করার এবং একটি সাধারণ কী তৈরি করার প্রস্তাব দেয় যার উপর প্রমাণীকরণ এবং সনাক্তকরণ বার্তাগুলি এনক্রিপ্ট করা যায়। SIGMA দুটি বিকল্প বর্ণনা করে:

• SIGMA-I - সক্রিয় আক্রমণ থেকে সূচনাকারীকে রক্ষা করে, নিষ্ক্রিয় আক্রমণ থেকে প্রতিক্রিয়াকারীকে রক্ষা করে: সূচনাকারী উত্তরদাতাকে প্রমাণীকরণ করে এবং যদি কিছু মেলে না, তবে এটি তার সনাক্তকরণ দেয় না। তার সাথে একটি সক্রিয় প্রোটোকল শুরু হলে আসামী তার পরিচয় দেয়। নিষ্ক্রিয় পর্যবেক্ষক কিছুই শেখে না;
  SIGMA-R - সক্রিয় আক্রমণ থেকে প্রতিক্রিয়াশীলকে রক্ষা করে, প্যাসিভ আক্রমণ থেকে সূচনাকারীকে। সবকিছু ঠিক বিপরীত, কিন্তু এই প্রোটোকলে চারটি হ্যান্ডশেক বার্তা ইতিমধ্যেই প্রেরণ করা হয়েছে।

  আমরা সিগমা-আই বেছে নিই কারণ এটি ক্লায়েন্ট-সার্ভার পরিচিত জিনিসগুলির থেকে আমরা যা আশা করি তার অনুরূপ: ক্লায়েন্ট শুধুমাত্র প্রমাণীকৃত সার্ভার দ্বারা স্বীকৃত হয়, এবং সবাই ইতিমধ্যে সার্ভারটি জানে৷ এছাড়াও কম হ্যান্ডশেক বার্তার কারণে এটি বাস্তবায়ন করা সহজ। প্রোটোকলে আমরা যা যোগ করি তা হল বার্তার অংশ এনক্রিপ্ট করা এবং শনাক্তকারী A কে শেষ বার্তার এনক্রিপ্ট করা অংশে স্থানান্তর করা:

  PubA, CookieA │ ╔════════════════════════════════════════└════════ ─────────── ───── ────────── ──────────────────── ─────────── ───── ──────>│ ║SignPrvA , SignPubA = load()║ │ │ ║PrvA, PubA = DHgen() ║ ┕ ═ DHgen() ║ ╂ ══════════ ═════════ ════╝ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ═══════════════ ═══════╗ │<─└──────────── ────────── ───── ────────── ║SignP rvB, SignPubB = load()║ │ │ ║ PrvB, PubB ┕ ┕ ─ ║ PubB ⚐ ─ DHgen() ════════ ════════════════╝ │ │ ╔══════════════════ ══╗ │ Enc((IdA, চিহ্ন( SignPrvA, (CookieB, CookieA, PubA)), MAC(IdA))) │ ║কী = DH(PrvA, PubB) ║ │──────────────────────────────── ─ ────────────────── ───────────────── ─────────── ──────>│ ║যাচাই করুন(কী, আইডিবি) ║ │ │ ║যাচাই করুন( সাইনপাববি, ...)║ │ │ ╚═════════════════════ ═════ ══╝ │ │
  

  • GOST R স্বাক্ষরের জন্য ব্যবহৃত হয় 34.10-2012 256-বিট কী সহ অ্যালগরিদম।
  • সর্বজনীন কী তৈরি করতে, 34.10-2012 VKO ব্যবহার করা হয়।
  • CMAC ম্যাক হিসাবে ব্যবহৃত হয়। প্রযুক্তিগতভাবে, এটি একটি ব্লক সাইফারের অপারেশনের একটি বিশেষ মোড, যা GOST R 34.13-2015 এ বর্ণিত হয়েছে। এই মোডের জন্য একটি এনক্রিপশন ফাংশন হিসাবে - ফড়িং (34.12-2015).
  • তার পাবলিক কী এর হ্যাশ কথোপকথনের শনাক্তকারী হিসাবে ব্যবহৃত হয়। একটি হ্যাশ হিসাবে ব্যবহৃত Stribog-256 (34.11/2012/256 XNUMX বিট)।

  হ্যান্ডশেক করার পরে, আমরা একটি শেয়ার্ড কী নিয়ে একমত হব। আমরা পরিবহন বার্তাগুলির প্রমাণীকৃত এনক্রিপশনের জন্য এটি ব্যবহার করতে পারি। এই অংশটি খুব সহজ এবং একটি ভুল করা কঠিন: আমরা বার্তা কাউন্টার বৃদ্ধি, বার্তা এনক্রিপ্ট, প্রমাণীকরণ (MAC) কাউন্টার এবং সাইফারটেক্সট, পাঠান. একটি বার্তা পাওয়ার সময়, আমরা পরীক্ষা করি যে কাউন্টারের প্রত্যাশিত মান আছে, কাউন্টারের সাথে সাইফারটেক্সট প্রমাণীকরণ করুন এবং এটি ডিক্রিপ্ট করুন। হ্যান্ডশেক বার্তা এনক্রিপ্ট করতে, পরিবহন বার্তাগুলি এবং কীভাবে সেগুলিকে প্রমাণীকরণ করতে আমার কী ব্যবহার করা উচিত? এই সমস্ত কাজের জন্য একটি কী ব্যবহার করা বিপজ্জনক এবং বোকামি। বিশেষ ফাংশন ব্যবহার করে কী তৈরি করা প্রয়োজন কেডিএফ (কী ডেরিভেশন ফাংশন)। আবার, আসুন চুল বিভক্ত না করে কিছু উদ্ভাবন করি: HKDF দীর্ঘ পরিচিত, ভাল গবেষণা এবং কোন পরিচিত সমস্যা নেই. দুর্ভাগ্যবশত, নেটিভ পাইথন লাইব্রেরিতে এই ফাংশন নেই, তাই আমরা ব্যবহার করি hkdf প্লাস্টিক ব্যাগ. HKDF অভ্যন্তরীণভাবে ব্যবহার করে এইচএমএসি, যা ঘুরে একটি হ্যাশ ফাংশন ব্যবহার করে। উইকিপিডিয়া পৃষ্ঠায় পাইথনে একটি উদাহরণ বাস্তবায়নের জন্য কোডের মাত্র কয়েকটি লাইন লাগে। 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)
  

  হ্যান্ডশেকটিবিএস স্বাক্ষরিত হবে কি. হ্যান্ডশেকটিবিই - কী এনক্রিপ্ট করা হবে। আমি 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 হ্যাশ হল 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-বিট সংখ্যা (urandom(8)), যার জন্য gost3410_vko.ukm_unmarshal() ব্যবহার করে এর বাইট উপস্থাপনা থেকে ডিসিরিয়ালাইজেশন প্রয়োজন। 34.10/2012/256 3410-বিটের জন্য VKO ফাংশন হল gost34102012256_vko.kek_XNUMX() (KEK - এনক্রিপশন কী)।

  তৈরি করা সেশন কীটি ইতিমধ্যেই একটি 256-বিট সিউডো-র্যান্ডম বাইট সিকোয়েন্স। অতএব, এটি অবিলম্বে HKDF ফাংশনে ব্যবহার করা যেতে পারে। যেহেতু GOST34112012256 হ্যাশলিব ইন্টারফেসকে সন্তুষ্ট করে, তাই এটি অবিলম্বে 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(কী) কল করে Kuznechik শুরু করা হয় এবং 34.13 ফাংশনে পাস করার জন্য উপযুক্ত .encrypt()/.decrypt() পদ্ধতি সহ একটি বস্তু ফেরত দেয়। MAC নিম্নরূপ গণনা করা হয়: gost3413.mac(GOST3412Kuznechik(key)।এনক্রিপ্ট, KUZNECHIK_BLOCKSIZE, সাইফারটেক্সট)। গণনা করা এবং প্রাপ্ত MAC তুলনা করতে, আপনি বাইট স্ট্রিংগুলির স্বাভাবিক তুলনা (==) ব্যবহার করতে পারবেন না, যেহেতু এই অপারেশনটি তুলনার সময় ফাঁস করে, যা সাধারণ ক্ষেত্রে, মারাত্মক দুর্বলতার কারণ হতে পারে পশু টিএলএস-এর উপর আক্রমণ। এর জন্য পাইথনের একটি বিশেষ ফাংশন আছে, 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 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, পাইডারাসন, এনএনসিপি, GoVPN, GOSTIM সম্পূর্ণরূপে বিনামুল্যের সফটওয়্যারশর্তাবলীর অধীনে বিতরণ করা হয় জিপিএলভি 3 +.

  সের্গেই মাতভিভ, সাইফারপাঙ্ক, সদস্য এসপিও ফাউন্ডেশন, পাইথন/গো-ডেভেলপার, প্রধান বিশেষজ্ঞ ফেডারেল স্টেট ইউনিটারি এন্টারপ্রাইজ "এসটিসি "এটলাস".

উত্স: www.habr.com