The book is an introduction to cryptography for programmers.

ఈ పుస్తకం ప్రోగ్రామర్ల కోసం క్రిప్టోగ్రఫీకి ఒక పరిచయం.


XOR is a fundamental operation in cryptography.

క్రిప్టోగ్రఫీలో XOR ఒక ప్రాథమిక చర్య.


The security of a one-time pad depends on the randomness of the key.

ఒక-సమయం ప్యాడ్ యొక్క భద్రత కీ యొక్క యాదృచ్ఛికతపై ఆధారపడి ఉంటుంది.


This book explains how to apply cryptosystems in real software.

ఈ పుస్తకం వాస్తవ సాఫ్ట్‌వేర్‌లో క్రిప్టోసిస్టమ్‌లను ఎలా ఉపయోగించాలో వివరిస్తుంది.


రచయిత 2013లో PyConలో ఒక ప్రసంగం ఇచ్చారు.


We must join them into one world where all programmers are educated in the basic underpinnings of information security.

అన్ని ప్రోగ్రామర్లు సమాచార భద్రత యొక్క ప్రాథమిక అంశాలలో విద్యావంతులయ్యే ఒక ప్రపంచంలో మనం వారితో చేరాలి.


The goal is to understand how complete cryptosystems work.

పూర్తి క్రిప్టోసిస్టమ్‌లు ఎలా పనిచేస్తాయో అర్థం చేసుకోవడమే లక్ష్యం.


The exercises focus on teaching cryptography by breaking inferior systems.

అభ్యాసాలు తక్కువ వ్యవస్థలను విచ్ఛిన్నం చేయడం ద్వారా క్రిప్టోగ్రఫీని బోధించడంపై దృష్టి పెడతాయి.


You will understand why all these primitives and constructions are necessary.

ఈ ప్రాథమిక అంశాలు మరియు నిర్మాణాలు ఎందుకు అవసరమో మీరు అర్థం చేసుకుంటారు.


ఈ పుస్తకం ఒక వారధిగా ఉండాలని ఆశిస్తోంది.


ఇది ఒక ఐచ్ఛికమైన, లోతైన విభాగం.


The entire Crypto 101 project is publicly developed on GitHub.

మొత్తం Crypto 101 ప్రాజెక్ట్ GitHubలో బహిరంగంగా అభివృద్ధి చేయబడింది.


All of your questions, comments and bug reports are highly appreciated.

మీ ప్రశ్నలు, వ్యాఖ్యలు మరియు బగ్ నివేదికలు చాలా ప్రశంసించబడతాయి.


If you don’t understand something after reading it, that’s a bug.

మీరు చదివిన తర్వాత ఏదైనా అర్థం చేసుకోకపోతే, అది ఒక లోపం.


This book would not have been possible without the support of many people.

అనేక మంది మద్దతు లేకుండా ఈ పుస్తకం సాధ్యం కాదు.


Exclusive or, often called XOR, is a Boolean binary operator.

ఎక్స్‌క్లూజివ్ లేదా, తరచుగా XOR అని పిలుస్తారు, ఇది బూలియన్ బైనరీ ఆపరేటర్.


XOR is true when either the first input or the second input, but not both, are true.

మొదటి ఇన్‌పుట్ లేదా రెండవ ఇన్‌పుట్, కానీ రెండూ కాకుండా, నిజమైనప్పుడు XOR నిజం అవుతుంది.


In mathematics and cryptography papers, exclusive or is generally represented by a cross in a circle: ⊕.

గణితం మరియు క్రిప్టోగ్రఫీ పత్రాలలో, ఎక్స్‌క్లూజివ్ లేదా సాధారణంగా వృత్తంలో ఒక క్రాస్ ద్వారా సూచించబడుతుంది: ⊕.


We’ll use the same notation in this book.

మేము ఈ పుస్తకంలో అదే సంజ్ఞామానాన్ని ఉపయోగిస్తాము.


If the bits are truly random, the attacker learns nothing about the plaintext.

బిట్‌లు నిజంగా యాదృచ్ఛికంగా ఉంటే, దాడి చేసే వ్యక్తి ప్లెయిన్‌టెక్స్ట్ గురించి ఏమీ తెలుసుకోలేడు.


వాటిని సరిపోయేలా చేయడానికి మనకు ఒక పథకం అవసరం.


ఆ ప్రక్రియను ప్యాడింగ్ అంటారు.


One way to pad would be to simply append a particular byte value until the plaintext is of the appropriate length.

ఒక మార్గం ఏమిటంటే, ప్లెయిన్ టెక్స్ట్ తగినంత పొడవుగా వచ్చే వరకు ఒక నిర్దిష్ట బైట్ విలువను జోడించడం.


To undo the padding, you just remove those bytes.

ప్యాడింగ్‌ను తీసివేయడానికి, మీరు ఆ బైట్‌లను తీసివేయండి.


This scheme has an obvious flaw: you can’t send messages that end in that particular byte value, or you will be unable to distinguish between padding and the actual message.

ఈ పథకానికి ఒక స్పష్టమైన లోపం ఉంది: మీరు ఆ నిర్దిష్ట బైట్ విలువతో ముగిసే సందేశాలను పంపలేరు, లేదా మీరు ప్యాడింగ్ మరియు అసలు సందేశం మధ్య తేడాను గుర్తించలేరు.


A better, and much more popular scheme, is PKCS#5/PKCS#7 padding.

మెరుగైన మరియు చాలా ప్రజాదరణ పొందిన పథకం PKCS#5/PKCS#7 ప్యాడింగ్.


Take the number of bytes you have to pad, and pad them with that many times the byte with that value.

మీరు ప్యాడ్ చేయవలసిన బైట్‌ల సంఖ్యను తీసుకోండి మరియు ఆ విలువతో ఉన్న బైట్‌ను అన్నిసార్లు ప్యాడ్ చేయండి.


For example, if the block size is 8 bytes, and the last block has the three bytes 12 34 45, the block becomes 12 34 45 05 05 05 05 05 after padding.

ఉదాహరణకు, బ్లాక్ సైజు 8 బైట్‌లు అయితే, చివరి బ్లాక్‌లో 12 34 45 అనే మూడు బైట్‌లు ఉంటే, ప్యాడింగ్ చేసిన తర్వాత బ్లాక్ 12 34 45 05 05 05 05 05 అవుతుంది.


If the plaintext happened to be exactly a multiple of the block size, an entire block of padding is used.

ప్లెయిన్ టెక్స్ట్ బ్లాక్ పరిమాణం యొక్క గుణిజంగా ఉంటే, మొత్తం ప్యాడింగ్ బ్లాక్ ఉపయోగించబడుతుంది.


Otherwise, the recipient would look at the last byte of the plaintext, treat it as a padding length, and almost certainly conclude the message was improperly padded.

లేకపోతే, గ్రహీత ప్లెయిన్ టెక్స్ట్ యొక్క చివరి బైట్‌ను చూస్తాడు, దానిని ప్యాడింగ్ పొడవుగా పరిగణిస్తాడు మరియు సందేశం సరిగ్గా ప్యాడ్ చేయలేదని దాదాపుగా నిర్ధారిస్తాడు.


We can refine CBC bit flipping attacks to trick a recipient into decrypting arbitrary messages!

మనము CBC బిట్ ఫ్లిప్పింగ్ దాడులను మెరుగుపరచవచ్చు, గ్రహీతను ఇష్టానుసారం సందేశాలను డీక్రిప్ట్ చేయడానికి మోసగించడానికి!


If the padding is incorrect, the recipient typically rejects the message, saying that the padding was invalid.

ప్యాడింగ్ సరిగ్గా లేకపోతే, గ్రహీత సాధారణంగా సందేశాన్ని తిరస్కరిస్తాడు, ప్యాడింగ్ చెల్లదని చెబుతాడు.


We can use that tiny bit of information about the padding of the plaintext to iteratively decrypt the entire message.

ప్లెయిన్ టెక్స్ట్ యొక్క ప్యాడింగ్ గురించి ఉన్న ఆ చిన్న సమాచారాన్ని ఉపయోగించి మొత్తం సందేశాన్ని పునరావృతంగా డీక్రిప్ట్ చేయవచ్చు.


The attacker will do this, one ciphertext block at a time, by trying to get an entire plaintext block worth of valid padding.

దాడి చేసే వ్యక్తి దీన్ని ఒక్కో సైఫర్‌టెక్స్ట్ బ్లాక్‌ను ఒక సమయంలో చేస్తాడు, మొత్తం ప్లెయిన్ టెక్స్ట్ బ్లాక్ విలువైన చెల్లుబాటు అయ్యే ప్యాడింగ్‌ను పొందడానికి ప్రయత్నిస్తాడు.


To mount this attack, an attacker only needs two things: A target ciphertext to decrypt and a padding oracle.

ఈ దాడిని చేయడానికి, ఒక దాడి చేసే వ్యక్తికి రెండు విషయాలు మాత్రమే అవసరం: డీక్రిప్ట్ చేయడానికి ఒక లక్ష్య సైఫర్‌టెక్స్ట్ మరియు ప్యాడింగ్ ఒరాకిల్.


For a long time, most systems did not even attempt to hide if the padding was valid or not.

చాలా కాలం పాటు, చాలా సిస్టమ్‌లు ప్యాడింగ్ చెల్లుబాటు అవుతుందా లేదా అని దాచడానికి కూడా ప్రయత్నించలేదు.


In this chapter, we’ll assume that PKCS#5/PKCS#7 padding is being used, since that’s the most popular option.

ఈ అధ్యాయంలో, మేము PKCS#5/PKCS#7 ప్యాడింగ్‌ను ఉపయోగిస్తున్నామని భావిస్తాము, ఎందుకంటే ఇది చాలా ప్రజాదరణ పొందిన ఎంపిక.


The attacker fills a block with arbitrary bytes.

దాడి చేసే వ్యక్తి ఒక బ్లాక్‌ను ఇష్టానుసారం బైట్‌లతో నింపుతాడు.


They also pick a target block from the ciphertext that they’d like to decrypt.

వారు డీక్రిప్ట్ చేయాలనుకుంటున్న సైఫర్‌టెక్స్ట్ నుండి ఒక లక్ష్య బ్లాక్‌ను కూడా ఎంచుకుంటారు.


The attacker tries all possible values for that last byte.

దాడి చేసే వ్యక్తి ఆ చివరి బైట్ కోసం అన్ని సాధ్యమయ్యే విలువలను ప్రయత్నిస్తాడు.


A scheme where the long-term key and the nonce had been securely combined wouldn’t have had this weakness.

దీర్ఘకాలిక కీ మరియు నాన్స్ సురక్షితంగా కలిపిన పథకం ఈ బలహీనతను కలిగి ఉండదు.


Many other standards including TLS were therefore not affected.

అందువల్ల TLSతో సహా అనేక ఇతర ప్రమాణాలు ప్రభావితం కాలేదు.


మళ్ళీ, దాడులు మరింత మెరుగ్గా మారతాయి.


Andreas Klein showed more extensive correlation between the key and the keystream.

ఆండ్రియాస్ క్లైన్ కీ మరియు కీస్ట్రీమ్ మధ్య మరింత విస్తృత సంబంధాన్ని చూపించాడు.


Instead of tens of millions of messages with the Fluhrer, Mantin, Shamir attacks, attackers now only needed several tens of thousands of messages to make the attack practical.

ఫ్లూహర్, మంటిన్, షమీర్ దాడులతో కూడిన లక్షల సందేశాలకు బదులుగా, దాడిని ఆచరణాత్మకంగా చేయడానికి ఇప్పుడు దాడులకు కొన్ని పదివేల సందేశాలు మాత్రమే అవసరం.


This was applied against WEP with great effect.

ఇది గొప్ప ప్రభావంతో WEPకి వ్యతిరేకంగా వర్తించబడింది.


In 2013, a team of researchers at Royal Holloway in London produced a combination of two independent practical attacks.

2013లో, లండన్‌లోని రాయల్ హోలోవేలో పరిశోధకుల బృందం రెండు స్వతంత్ర ఆచరణాత్మక దాడుల కలయికను ఉత్పత్తి చేసింది.


These attacks proved to be very damning for RC4: while RC4’s weaknesses had been known for a long time, they finally drove the point home for everyone that it really shouldn’t be used anymore.

ఈ దాడులు RC4కి చాలా ప్రమాదకరమని నిరూపించబడ్డాయి: RC4 యొక్క బలహీనతలు చాలా కాలంగా తెలిసినప్పటికీ, అది ఇకపై ఉపయోగించకూడదని అందరికీ స్పష్టం చేసింది.


The first attack is based on single-byte biases in the first 256 bytes of the keystream.

మొదటి దాడి కీస్ట్రీమ్ యొక్క మొదటి 256 బైట్‌లలోని సింగిల్-బైట్ పక్షపాతాలపై ఆధారపడి ఉంటుంది.


By performing statistical analysis on the keystreams produced by a large number of keys, they were able to analyze the already well-known biases in the early keystream bytes of RC4 in much greater detail.

అనేక కీలు ఉత్పత్తి చేసిన కీస్ట్రీమ్‌లపై గణాంక విశ్లేషణను నిర్వహించడం ద్వారా, వారు RC4 యొక్క ప్రారంభ కీస్ట్రీమ్ బైట్‌లలో ఇప్పటికే బాగా తెలిసిన పక్షపాతాలను మరింత వివరంగా విశ్లేషించగలిగారు.


The second attack is based on double byte biases anywhere in the keystream.

రెండవ దాడి కీస్ట్రీమ్‌లో ఎక్కడైనా డబుల్ బైట్ పక్షపాతాలపై ఆధారపడి ఉంటుంది.


It turns out that adjacent bytes of the keystream have an exploitable relation, whereas in an ideal stream cipher you would expect them to be completely independent.

కీస్ట్రీమ్ యొక్క ప్రక్కనే ఉన్న బైట్‌లకు దోపిడీ సంబంధం ఉందని తేలింది, అయితే ఆదర్శవంతమైన స్ట్రీమ్ సైఫర్‌లో అవి పూర్తిగా స్వతంత్రంగా ఉంటాయని మీరు ఆశిస్తారు.


This table may seem a bit daunting at first.

ఈ పట్టిక మొదట కొంచెం భయానకంగా అనిపించవచ్చు.


Suppose that RC4 was a good stream cipher, and all values occurred with equal probability.

RC4 ఒక మంచి స్ట్రీమ్ సైఫర్ అని అనుకుందాం మరియు అన్ని విలువలు సమాన సంభావ్యతతో సంభవించాయి.


By writing the probability in the 2 −16 (1 + 2 −k ) form, it’s easier to see how much RC4 deviates from what you’d expect from an ideal stream cipher.

సంభావ్యతను 2 −16 (1 + 2 −k ) రూపంలో రాయడం ద్వారా, ఆదర్శవంతమైన స్ట్రీమ్ సైఫర్ నుండి మీరు ఏమి ఆశిస్తారో RC4 ఎంత విచలనం చెందుతుందో చూడటం సులభం.


So, let’s try to read the first line of the table.

కాబట్టి, పట్టిక యొక్క మొదటి లైన్‌ను చదవడానికి ప్రయత్నిద్దాం.


It says that when the first byte i = 1 of any 256-byte chunk from the cipher is 0, then the byte following it is slightly more likely (1 + 2 −9 times as likely, to be exact) to be 0 than for it to be any other number.

సైఫర్ నుండి ఏదైనా 256-బైట్ ముక్క యొక్క మొదటి బైట్ i = 1 0 అయితే, దానిని అనుసరించే బైట్ కొంచెం ఎక్కువగా ఉంటుంది (1 + 2 −9 రెట్లు ఎక్కువ, ఖచ్చితంగా చెప్పాలంటే) 0 గా ఉండటానికి ఏదైనా ఇతర సంఖ్య కంటే.


We can also see that when one of the keystream bytes is 255, you can make many predictions about the next byte, depending on where it occurs in the keystream.

కీస్ట్రీమ్ బైట్‌లలో ఒకటి 255 అయినప్పుడు, కీస్ట్రీమ్‌లో అది ఎక్కడ సంభవిస్తుందో దాని ఆధారంగా మీరు తదుపరి బైట్ గురించి అనేక అంచనాలు వేయవచ్చు.


These attacks have primarily focused on the cipher itself, and haven’t been fully optimized for practical attacks on, say, web services.

ఈ దాడులు ప్రధానంగా సైఫర్‌పైనే దృష్టి సారించాయి మరియు వెబ్ సేవలపై ఆచరణాత్మక దాడుల కోసం పూర్తిగా ఆప్టిమైజ్ చేయబడలేదు.


The attacker does learn that the message exists, and, in this simple scheme, the length of the message.

ఆക്രമించే వ్యక్తి సందేశం ఉనికిని మరియు ఈ సాధారణ పథకంలో సందేశం యొక్క పొడవును తెలుసుకుంటాడు.


While this typically isn’t too important, there are situations where this might matter, and there are secure cryptosystems to both hide the existence and the length of a message.

ఇది సాధారణంగా చాలా ముఖ్యమైనది కానప్పటికీ, ఇది ముఖ్యమైనదిగా అనిపించే పరిస్థితులు ఉన్నాయి మరియు సందేశం యొక్క ఉనికిని మరియు పొడవును దాచడానికి సురక్షితమైన క్రిప్టోసిస్టమ్‌లు ఉన్నాయి.


The one-time pad security guarantee only holds if it is used correctly.

ఒక-సమయం ప్యాడ్ భద్రతా హామీ సరిగ్గా ఉపయోగిస్తేనే చెల్లుతుంది.


First of all, the one-time pad has to consist of truly random data.

అన్నింటిలో మొదటిది, ఒక-సమయం ప్యాడ్ నిజంగా యాదృచ్ఛిక డేటాతో కూడి ఉండాలి.


Secondly, the one-time pad can only be used once (hence the name).

రెండవది, ఒక-సమయం ప్యాడ్‌ను ఒక్కసారి మాత్రమే ఉపయోగించవచ్చు (అందుకే ఆ పేరు).


Unfortunately, most commercial products that claim to be ”one-time pads” are snake oil, and don’t satisfy at least one of those two properties.

దురదృష్టవశాత్తు, ”ఒక-సమయం ప్యాడ్‌లు” అని చెప్పుకునే చాలా వాణిజ్య ఉత్పత్తులు పాము నూనె మరియు ఆ రెండు లక్షణాలలో కనీసం ఒకదానిని సంతృప్తిపరచవు.


The first issue is that they use various deterministic constructs to produce the one-time pad, instead of using truly random data.

మొదటి సమస్య ఏమిటంటే, వారు నిజంగా యాదృచ్ఛిక డేటాను ఉపయోగించకుండా, ఒక-సమయం ప్యాడ్‌ను ఉత్పత్తి చేయడానికి వివిధ నిర్ధారిత నిర్మాణాలను ఉపయోగిస్తారు.


That isn’t necessarily insecure: in fact, the most obvious example, a synchronous stream cipher, is something we’ll see later in the book.

అది తప్పనిసరిగా అసురక్షితం కాదు: వాస్తవానికి, అత్యంత స్పష్టమైన ఉదాహరణ, ఒక సమకాలిక స్ట్రీమ్ సైఫర్, పుస్తకంలో తరువాత మనం చూసేది.


However, it does invalidate the ”unbreakable” security property of one-time pads.

అయితే, ఇది ఒక-సమయం ప్యాడ్‌ల యొక్క ”విచ్ఛిన్నం చేయలేని” భద్రతా లక్షణాన్ని చెల్లదు.


The end user would be better served by a more honest cryptosystem, instead of one that lies about its security properties.

అతని భద్రతా లక్షణాల గురించి అబద్ధం చెప్పే దానికంటే, చివరి వినియోగదారు మరింత నిజాయితీ గల క్రిప్టోసిస్టమ్‌తో బాగా పని చేస్తారు.


The other issue is with key reuse, which is much more serious.

కీని తిరిగి ఉపయోగించడం అనేది మరొక సమస్య, ఇది చాలా తీవ్రమైనది.


Suppose an attacker gets two ciphertexts with the same ”one-time” pad.

ఒక దుండగుడు ఒకే ”ఒక-సమయం” ప్యాడ్‌తో రెండు సైఫర్‌టెక్స్ట్‌లను పొందాడని అనుకుందాం.


The problem is that even the result of the XOR operation on two plaintexts contains quite a bit information about the plaintexts themselves.

సమస్య ఏమిటంటే, రెండు సాదా వచనాలపై XOR ఆపరేషన్ యొక్క ఫలితం కూడా సాదా వచనాల గురించి కొంత సమాచారాన్ని కలిగి ఉంటుంది.


A classical approach to breaking multi-time pad systems involves ”crib-dragging”, a process that uses small sequences that are expected to occur with high probability.

బహుళ-సమయ ప్యాడ్ సిస్టమ్‌లను విచ్ఛిన్నం చేయడానికి ఒక సాంప్రదాయ విధానంలో ”క్రిబ్-డ్రాగింగ్” ఉంటుంది, ఇది అధిక సంభావ్యతతో సంభవించే చిన్న సీక్వెన్స్‌లను ఉపయోగిస్తుంది.


If we could correctly guess the plaintext for one of the messages, let’s say Cj, we’d know K.

ఒక సందేశం కోసం మనం సాదా వచనాన్ని సరిగ్గా ఊహించగలిగితే, Cj అని అనుకుందాం, అప్పుడు మనకు K తెలుస్తుంది.


Guessing parts of the plaintext is a lot easier than guessing the entire plaintext.

సాదా వచనంలోని భాగాలను ఊహించడం మొత్తం సాదా వచనాన్ని ఊహించడం కంటే చాలా సులభం.


If we know more about the plaintext, we can make even better guesses.

సాదా వచనం గురించి మనకు మరింత తెలిస్తే, మనం మరింత మంచి అంచనాలు వేయవచ్చు.


If our guess is correct, we know all the other plaintexts at that position as well, using the technique described earlier.

మన అంచనా సరిగ్గా ఉంటే, ఇంతకు ముందు వివరించిన పద్ధతిని ఉపయోగించి, ఆ స్థానంలో ఉన్న ఇతర సాదా వచనాలన్నీ కూడా మనకు తెలుసు.


These small, highly probable sequences are called ”cribs” because they’re the start of a larger decryption process.

ఈ చిన్న, అత్యంత సంభావ్య శ్రేణులను ”క్రిబ్‌లు” అని పిలుస్తారు, ఎందుకంటే అవి పెద్ద డీక్రిప్షన్ ప్రక్రియకు ప్రారంభం.


Real one-time pads, implemented properly, have an extremely strong security guarantee.

నిజమైన ఒక-సమయం ప్యాడ్‌లు, సరిగ్గా అమలు చేయబడితే, చాలా బలమైన భద్రతా హామీని కలిగి ఉంటాయి.


Even though 3DES is significantly worse in terms of performance and slightly worse in terms of security, 3DES is still the workhorse of the financial industry.

3DES పనితీరు పరంగా చాలా అధ్వాన్నంగా ఉంది మరియు భద్రతా పరంగా కొంచెం అధ్వాన్నంగా ఉన్నప్పటికీ, 3DES ఇప్పటికీ ఆర్థిక పరిశ్రమకు వెన్నెముకగా ఉంది.


With a plethora of standards already in existence and new ones continuing to be created, it will probably continue to be used for many years to come.

ఇప్పటికే చాలా ప్రమాణాలు ఉండగా, కొత్తవి కూడా రూపొందుతూనే ఉన్నాయి, ఇది రాబోయే చాలా సంవత్సరాల పాటు ఉపయోగించబడుతూనే ఉంటుంది.


For example, we can only send messages of a very limited length: the block length of the block cipher.

ఉదాహరణకు, మనం చాలా పరిమిత పొడవు గల సందేశాలను మాత్రమే పంపగలము: బ్లాక్ సైఫర్ యొక్క బ్లాక్ పొడవు.


Ideally, that stream could be as long as we’d like; real-world stream ciphers have limits, but they are normally sufficiently large that they don’t pose a practical problem.

ఆదర్శవంతంగా, ఆ స్ట్రీమ్ మనకు కావలసినంత పొడవుగా ఉండవచ్చు; వాస్తవ-ప్రపంచ స్ట్రీమ్ సైఫర్‌లకు పరిమితులు ఉన్నాయి, కానీ అవి సాధారణంగా తగినంత పెద్దవిగా ఉంటాయి, అవి ఆచరణాత్మక సమస్యను కలిగించవు.


This scheme is called ECB mode (Electronic Code Book Mode), and it is one of the many ways that block ciphers can be used to construct stream ciphers.

ఈ పథకాన్ని ECB మోడ్ (ఎలక్ట్రానిక్ కోడ్ బుక్ మోడ్) అంటారు మరియు స్ట్రీమ్ సైఫర్‌లను నిర్మించడానికి బ్లాక్ సైఫర్‌లను ఉపయోగించగల అనేక మార్గాలలో ఇది ఒకటి.


In ECB mode, identical input blocks will always map to identical output blocks.

ECB మోడ్‌లో, ఒకే ఇన్పుట్ బ్లాక్‌లు ఎల్లప్పుడూ ఒకే అవుట్‌పుట్ బ్లాక్‌లకు మ్యాప్ చేయబడతాయి.


By dividing the ciphertext stream up into blocks, an attacker would only be able to see that a ciphertext block, and therefore a plaintext block, was repeated.

సైఫర్‌టెక్స్ట్ స్ట్రీమ్‌ను బ్లాక్‌లుగా విభజించడం ద్వారా, ఒక దాడి చేసే వ్యక్తి సైఫర్‌టెక్స్ట్ బ్లాక్ మరియు అందువల్ల ఒక ప్లెయిన్‌టెక్స్ట్ బ్లాక్ పునరావృతమైందని మాత్రమే చూడగలరు.


First, we’ll exploit the fact that repeating plaintext blocks result in repeating ciphertext blocks, by visually inspecting an encrypted image.

ముందుగా, గుప్తీకరించిన చిత్రాన్ని దృశ్యపరంగా పరిశీలించడం ద్వారా, పునరావృతమయ్యే ప్లెయిన్‌టెక్స్ట్ బ్లాక్‌లు పునరావృతమయ్యే సైఫర్‌టెక్స్ట్ బ్లాక్‌లకు దారి తీస్తాయనే వాస్తవాన్ని మేము ఉపయోగిస్తాము.


Then, we’ll demonstrate that attackers can often decrypt messages encrypted in ECB mode by communicating with the person performing the encryption.

అనంతరం, గుప్తీకరణను నిర్వహిస్తున్న వ్యక్తితో కమ్యూనికేట్ చేయడం ద్వారా ECB మోడ్‌లో గుప్తీకరించబడిన సందేశాలను తరచుగా డీక్రిప్ట్ చేయవచ్చని మేము నిరూపిస్తాము.


Because identical blocks of pixels in the plaintext will map to identical blocks of pixels in the ciphertext, the global structure of the image is largely preserved.

ప్లెయిన్‌టెక్స్ట్‌లోని ఒకే పిక్సెల్‌ల బ్లాక్‌లు సైఫర్‌టెక్స్ట్‌లోని ఒకే పిక్సెల్‌ల బ్లాక్‌లకు మ్యాప్ చేయబడతాయి కాబట్టి, చిత్రం యొక్క గ్లోబల్ నిర్మాణం చాలా వరకు అలాగే ఉంటుంది.


For an uncompressed bitmap with three color channels of 8 bit depth, each pixel takes 24 bits to store.

8 బిట్ లోతుతో మూడు రంగు ఛానెల్‌లతో కూడిన కుదించబడని బిట్‌మ్యాప్ కోసం, ప్రతి పిక్సెల్ నిల్వ చేయడానికి 24 బిట్‌లను తీసుకుంటుంది.


Keep in mind that ”looking like random noise” doesn’t mean something is properly encrypted: it just means that we can’t inspect it using methods this trivial.

”యాదృచ్ఛిక శబ్దంలా కనిపించడం” అంటే ఏదో సరిగ్గా గుప్తీకరించబడిందని కాదు: అంటే మనం ఈ సాధారణ పద్ధతులను ఉపయోగించి దాన్ని పరిశీలించలేము.


In this section, we’ll study a different, active attack, where the attacker actively communicates with their target.

ఈ విభాగంలో, దాడి చేసే వ్యక్తి తన లక్ష్యంతో చురుకుగా కమ్యూనికేట్ చేసే వేరే, చురుకైన దాడిని మేము అధ్యయనం చేస్తాము.


Given some data A chosen by the attacker, the oracle will encrypt that data, followed by a secret suffix S, in ECB mode.

దాడి చేసే వ్యక్తి ఎంచుకున్న కొన్ని డేటా A ఇచ్చినట్లయితే, ఒరాకిల్ ఆ డేటాను గుప్తీకరిస్తుంది, ఆ తర్వాత రహస్య సఫిక్స్ S, ECB మోడ్‌లో ఉంటుంది.


దాడి చేసే వ్యక్తి లక్ష్యం దానిని డీక్రిప్ట్ చేయడం.


A simple example would be a cookie encrypted with ECB, where the prefix A is a name or an e-mail address field, controlled by the attacker.

ఒక సాధారణ ఉదాహరణ ఏమిటంటే ECBతో గుప్తీకరించబడిన కుకీ, ఇక్కడ A ఉపసర్గ అనేది దాడి చేసే వ్యక్తి నియంత్రించే పేరు లేదా ఇ-మెయిల్ చిరునామా ఫీల్డ్.


The attacker starts by sending in a plaintext A that’s just one byte shorter than the block size.

దాడి చేసే వ్యక్తి బ్లాక్ పరిమాణం కంటే ఒకే ఒక్క బైట్ తక్కువగా ఉన్న ప్లెయిన్‌టెక్స్ట్ Aని పంపడం ద్వారా ప్రారంభిస్తాడు.


This allows them to brute-force a block in p·b attempts, where p is the number of possible values for each byte (so, for 8-bit bytes, that’s 256) and b is the block size.

ఇది p·b ప్రయత్నాలలో ఒక బ్లాక్‌ను బ్రూట్-ఫోర్స్ చేయడానికి అనుమతిస్తుంది, ఇక్కడ p అనేది ప్రతి బైట్ కోసం సాధ్యమయ్యే విలువల సంఖ్య (అంటే, 8-బిట్ బైట్‌ల కోసం, అది 256) మరియు b అనేది బ్లాక్ పరిమాణం.


In the real world, block ciphers are used in systems that encrypt large amounts of data all the time.

నిజ ప్రపంచంలో, బ్లాక్ సైఫర్‌లను ఎల్లప్పుడూ పెద్ద మొత్తంలో డేటాను గుప్తీకరించే సిస్టమ్‌లలో ఉపయోగిస్తారు.


Even when we use idealized block ciphers with unrealistic properties, such as block sizes of more than a thousand bits, an attacker ends up being able to decrypt the ciphertexts.

అవాస్తవిక లక్షణాలతో కూడిన ఆదర్శవంతమైన బ్లాక్ సైఫర్‌లను ఉపయోగించినప్పుడు కూడా, వెయ్యి బిట్‌ల కంటే ఎక్కువ బ్లాక్ పరిమాణాలు వంటివి, దాడి చేసే వ్యక్తి సైఫర్‌టెక్స్ట్‌లను డీక్రిప్ట్ చేయగలుగుతాడు.


There's no way for him to prove that he's the legitimate participant.

అతను నిజమైన భాగస్వామి అని నిరూపించడానికి మార్గం లేదు.


As far as Alice can tell, Bob just chose a few random numbers.

ఆలిస్ చెప్పగలిగినంత వరకు, బాబ్ కొన్ని యాదృచ్ఛిక సంఖ్యలను ఎంచుకున్నాడు.


There’s no way to link any key that Bob has with any key that Alice has.

బాబ్ కలిగి ఉన్న ఏదైనా కీని, ఆలిస్ కలిగి ఉన్న ఏదైనా కీతో లింక్ చేయడానికి వీలు లేదు.


Attacks like these are called man-in-the-middle (MITM) attacks, because the attacker (Mallory) is in between the two peers (Alice and Bob).

ఇటువంటి దాడులను మ్యాన్-ఇన్-ది-మిడిల్ (MITM) దాడులు అంటారు, ఎందుకంటే దాడి చేసే వ్యక్తి (మల్లరీ) ఇద్దరు సహచరుల (ఆలిస్ మరియు బాబ్) మధ్యలో ఉంటాడు.


Given that the network infrastructure that we typically use to send messages is run by many different operators, this kind of attack scenario is very realistic, and a secure cryptosystem will have to address them somehow.

సాధారణంగా మనం సందేశాలను పంపడానికి ఉపయోగించే నెట్‌వర్క్ మౌలిక సదుపాయాలు చాలా మంది ఆపరేటర్లచే నిర్వహించబడుతున్నందున, ఈ రకమైన దాడి దృశ్యం చాలా వాస్తవికమైనది మరియు సురక్షితమైన క్రిప్టోసిస్టమ్ వాటిని ఎలాగైనా పరిష్కరించాలి.


While the Diffie-Hellman protocol successfully produced a shared secret between two peers, there are clearly some pieces of the puzzle still missing to build those cryptosystems.

డిఫీ-హెల్మన్ ప్రోటోకాల్ ఇద్దరు సహచరుల మధ్య విజయవంతంగా భాగస్వామ్య రహస్యాన్ని ఉత్పత్తి చేసినప్పటికీ, ఆ క్రిప్టోసిస్టమ్‌లను నిర్మించడానికి ఇంకా కొన్ని ముక్కలు తప్పిపోయాయి.


We need tools that help us authenticate Alice to Bob and vice versa, and we need tools that help guarantee message integrity, allowing the receiver to verify that the received messages are in fact the messages the sender intended to send.

ఆలిస్‌ను బాబ్‌కు మరియు వైస్ వెర్సాకు ప్రామాణీకరించడానికి సహాయపడే సాధనాలు మనకు అవసరం, అలాగే స్వీకర్తకు స్వీకరించిన సందేశాలు వాస్తవానికి పంపినవారు పంపించాలనుకున్న సందేశాలేనని ధృవీకరించడానికి వీలు కల్పించే సందేశ సమగ్రతకు హామీ ఇచ్చే సాధనాలు మనకు అవసరం.


Suppose, that you could have a cryptosystem that didn’t involve a single secret key, but instead had a key pair: one public key, which you freely distribute, and a private one, which you keep to yourself.

ఒక రహస్య కీని కలిగి ఉండని, బదులుగా కీ జతను కలిగి ఉన్న క్రిప్టోసిస్టమ్ మీకు ఉండవచ్చని అనుకుందాం: ఒకటి పబ్లిక్ కీ, మీరు స్వేచ్ఛగా పంపిణీ చేస్తారు మరియు ప్రైవేట్ కీ, మీరు మీ కోసం ఉంచుకుంటారు.


People can encrypt information intended for you by using your public key.

మీ పబ్లిక్ కీని ఉపయోగించి మీ కోసం ఉద్దేశించిన సమాచారాన్ని ప్రజలు గుప్తీకరించవచ్చు.


The information is then impossible to decipher without your private key.

అప్పుడు మీ ప్రైవేట్ కీ లేకుండా సమాచారాన్ని అర్థం చేసుకోవడం అసాధ్యం.


దీనిని పబ్లిక్-కీ ఎన్‌క్రిప్షన్ అంటారు.


For a long time, people thought this was impossible.

చాలా కాలం పాటు, ఇది అసాధ్యమని ప్రజలు భావించారు.


However, starting in the 1970s, such algorithms started appearing.

అయితే, 1970 ల నుండి, అటువంటి అల్గారిథమ్‌లు కనిపించడం ప్రారంభించాయి.


The first publicly available encryption scheme was produced by three cryptographers from MIT: Ron Rivest, Adi Shamir and Leonard Adleman.

మొదటి బహిరంగంగా లభించే ఎన్‌క్రిప్షన్ పథకాన్ని MITకి చెందిన ముగ్గురు క్రిప్టోగ్రాఫర్‌లు రూపొందించారు: రాన్ రివెట్, ఆది షామిర్ మరియు లియోనార్డ్ అడెల్మాన్.


The algorithm they published is still the most common one today, and carries the first letters of their last names: RSA.

వారు ప్రచురించిన అల్గారిథమ్ ఇప్పటికీ నేడు అత్యంత సాధారణమైనది మరియు వారి ఇంటిపేర్ల మొదటి అక్షరాలను కలిగి ఉంది: RSA.


Public-key algorithms aren’t limited to encryption.

పబ్లిక్-కీ అల్గారిథమ్‌లు ఎన్‌క్రిప్షన్‌కు పరిమితం కాలేదు.


In fact, you’ve already seen a public-key algorithm in this book that isn’t directly used for encryption.

వాస్తవానికి, మీరు ఈ పుస్తకంలో ఇప్పటికే ఎన్‌క్రిప్షన్ కోసం నేరుగా ఉపయోగించని పబ్లిక్-కీ అల్గారిథమ్‌ను చూశారు.


There are actually three related classes of public-key algorithms:

వాస్తవానికి మూడు సంబంధిత తరగతుల పబ్లిక్-కీ అల్గారిథమ్‌లు ఉన్నాయి:


Key exchange algorithms, such as Diffie-Hellman, which allow you to agree on a shared secret across an insecure medium.

డిఫీ-హెల్మన్ వంటి కీ మార్పిడి అల్గారిథమ్‌లు, ఇవి అసురక్షిత మాధ్యమం ద్వారా భాగస్వామ్య రహస్యంపై అంగీకరించడానికి మిమ్మల్ని అనుమతిస్తాయి.


Encryption algorithms, such as the ones we’ll discuss in this chapter, which allow people to encrypt without having to agree on a shared secret.

ఈ అధ్యాయంలో మనం చర్చించే వాటి వంటి ఎన్‌క్రిప్షన్ అల్గారిథమ్‌లు, ఇవి భాగస్వామ్య రహస్యంపై అంగీకరించకుండానే ప్రజలను గుప్తీకరించడానికి అనుమతిస్తాయి.


HKDF is a key derivation function designed for high entropy inputs.

HKDF అనేది అధిక ఎంట్రోపీ ఇన్పుట్‌ల కోసం రూపొందించబడిన కీ డిరైవేషన్ ఫంక్షన్.


It is specifically not designed to be secure for low-entropy inputs such as passwords.

ఇది ముఖ్యంగా పాస్‌వర్డ్‌లు వంటి తక్కువ ఎంట్రోపీ ఇన్‌పుట్‌ల కోసం సురక్షితంగా రూపొందించబడలేదు.


Previously, key derivation was often something that was done ad hoc for a particular standard.

మునుపు, కీ డిరైవేషన్ తరచుగా ఒక నిర్దిష్ట ప్రమాణం కోసం ప్రత్యేకంగా చేయబడేది.


HKDF HMAC ఆధారంగా పనిచేస్తుంది.


The extraction phase is responsible for extracting a small amount of data with a high entropy content.

ఎక్స్‌ట్రాక్షన్ దశ అధిక ఎంట్రోపీ కంటెంట్‌తో కొద్ది మొత్తంలో డేటాను సంగ్రహించడానికి బాధ్యత వహిస్తుంది.


ఉప్పు విలువ ఐచ్ఛికం.


Even a fairly low-entropy salt can already contribute significantly to the security of the key derivation function.

తక్కువ ఎంట్రోపీ ఉప్పు కూడా కీ డిరైవేషన్ ఫంక్షన్ యొక్క భద్రతకు గణనీయంగా దోహదం చేస్తుంది.


While the extraction phase is very good at concentrating entropy, it is not capable of amplifying entropy.

ఎక్స్‌ట్రాక్షన్ దశ ఎంట్రోపీని కేంద్రీకరించడంలో చాలా మంచిది, కానీ ఎంట్రోపీని విస్తరించలేకపోతుంది.


In the expansion phase, the random data extracted from the inputs in the extraction phase is expanded into as much data as is required.

విస్తరణ దశలో, సంగ్రహణ దశలో ఇన్‌పుట్‌ల నుండి సంగ్రహించబడిన యాదృచ్ఛిక డేటాకు ఎంత డేటా అవసరమో అంతగా విస్తరించబడుతుంది.


The "info" parameter is intended to contain some application-specific context.

"సమాచారం" పరామితి కొన్ని అప్లికేషన్-నిర్దిష్ట సందర్భాలను కలిగి ఉండటానికి ఉద్దేశించబడింది.


Many cryptographic systems require random numbers.

అనేక క్రిప్టోగ్రాఫిక్ సిస్టమ్‌లకు యాదృచ్ఛిక సంఖ్యలు అవసరం.


Producing random numbers is a fairly intricate process.

యాదృచ్ఛిక సంఖ్యలను ఉత్పత్తి చేయడం చాలా క్లిష్టమైన ప్రక్రియ.


True random number generators get their randomness from physical processes.

నిజమైన యాదృచ్ఛిక సంఖ్య జనరేటర్లు వాటి యాదృచ్ఛికతను భౌతిక ప్రక్రియల నుండి పొందుతాయి.


Systems like dice are still in common use today.

పాచికలు వంటి వ్యవస్థలు నేటికీ సాధారణ వాడుకలో ఉన్నాయి.


There are several categories of physical processes that are used for hardware random number generation.

హార్డ్‌వేర్ యాదృచ్ఛిక సంఖ్య ఉత్పత్తి కోసం ఉపయోగించే అనేక రకాల భౌతిక ప్రక్రియలు ఉన్నాయి.


One example of a quantum physical process used to produce random numbers is radioactive decay.

యాదృచ్ఛిక సంఖ్యలను ఉత్పత్తి చేయడానికి ఉపయోగించే క్వాంటం భౌతిక ప్రక్రియకు ఒక ఉదాహరణ రేడియోధార్మిక క్షయం.


Shot noise is another quantum physical process used to produce random numbers.

షాట్ శబ్దం యాదృచ్ఛిక సంఖ్యలను ఉత్పత్తి చేయడానికి ఉపయోగించే మరొక క్వాంటం భౌతిక ప్రక్రియ.


Nyquist noise is the noise that occurs from charge carriers traveling through a medium.

నైక్విస్ట్ శబ్దం అనేది ఛార్జ్ క్యారియర్‌లు ఒక మాధ్యమం ద్వారా ప్రయాణించడం వల్ల సంభవించే శబ్దం.


As an application developer, you should never be making a choice between one of them.

ఒక అప్లికేషన్ డెవలపర్‌గా, మీరు వాటిలో ఒకదానిని ఎంచుకోవడానికి ఎప్పుడూ ప్రయత్నించకూడదు.


Mersenne Twister is a very common pseudorandom number generator.

మెర్సెన్ ట్విస్టర్ చాలా సాధారణమైన సూడోరాండమ్ నంబర్ జనరేటర్.


The password would result in the same hash everywhere.

పాస్‌వర్డ్ ప్రతిచోటా ఒకే హాష్‌ను ఉత్పత్తి చేస్తుంది.


This problem was generally solved by using salts.

ఈ సమస్యను సాధారణంగా లవణాలను ఉపయోగించడం ద్వారా పరిష్కరించారు.


By mixing the password with some random value before hashing it, you could produce completely different hash values.

హాష్ చేయడానికి ముందు పాస్‌వర్డ్‌ను కొన్ని యాదృచ్ఛిక విలువతో కలిపితే, మీరు పూర్తిగా భిన్నమైన హాష్ విలువలను ఉత్పత్తి చేయవచ్చు.


The salt value is stored next to the password hash in the database.

డేటాబేస్‌లో పాస్‌వర్డ్ హాష్ పక్కన ఉప్పు విలువ నిల్వ చేయబడుతుంది.


When the user authenticates using the password, you just combine the salt with the password, hash it, and compare it against the stored hash.

వినియోగదారుడు పాస్‌వర్డ్‌ను ఉపయోగించి ప్రమాణీకరించినప్పుడు, మీరు ఉప్పును పాస్‌వర్డ్‌తో కలిపి, హాష్ చేసి, నిల్వ చేసిన హాష్‌తో సరిపోల్చండి.


If you pick a sufficiently large, cryptographically random salt, you’ve completely defeated ahead-of-time attacks.

మీరు తగినంత పెద్ద, క్రిప్టోగ్రాఫిక్‌గా యాదృచ్ఛిక ఉప్పును ఎంచుకుంటే, మీరు ముందుగానే దాడులను పూర్తిగా ఓడిస్తారు.


In order to successfully mount a rainbow table attack, an attacker would have to have a separate table for each of those salt values.

రెయిన్‌బో టేబుల్ దాడిని విజయవంతంగా నిర్వహించడానికి, దాడి చేసే వ్యక్తి ఆ ఉప్పు విలువల్లో ప్రతి ఒక్కదానికి ఒక ప్రత్యేక పట్టికను కలిగి ఉండాలి.


Computing a single table takes a decent amount of time; computing 2^160 different tables is impossible.

ఒకే పట్టికను గణించడానికి కొంత సమయం పడుతుంది; 2^160 విభిన్న పట్టికలను గణించడం అసాధ్యం.


Many systems used a single salt for all users.

అనేక వ్యవస్థలు వినియోగదారులందరికీ ఒకే ఉప్పును ఉపయోగించాయి.


While that prevented an ahead-of-time rainbow table attack, it still allowed attackers to attack all passwords simultaneously, once they knew the value of the salt.

అది ముందుగానే రెయిన్‌బో టేబుల్ దాడిని నిరోధించినప్పటికీ, ఉప్పు విలువ తెలిసిన తర్వాత, ఇది ఇప్పటికీ దాడి చేసేవారిని అన్ని పాస్‌వర్డ్‌లపై ఒకేసారి దాడి చేయడానికి అనుమతించింది.


An attacker would simply compute a single rainbow table for that salt, and compare the results with the hashed passwords from the database.

దాడి చేసే వ్యక్తి ఆ ఉప్పు కోసం ఒకే రెయిన్‌బో పట్టికను లెక్కిస్తాడు మరియు ఫలితాలను డేటాబేస్ నుండి హాష్ చేసిన పాస్‌వర్డ్‌లతో పోల్చుతాడు.


Perhaps the biggest problem with salts is that many programmers were suddenly convinced they were doing the right thing.

బహుశా లవణాలతో అతిపెద్ద సమస్య ఏమిటంటే చాలా మంది ప్రోగ్రామర్లు తాము సరైన పని చేస్తున్నామని అకస్మాత్తుగా నమ్మారు.


Modern attacks on weak password systems To a modern attack, salts quite simply don’t help.

బలహీనమైన పాస్‌వర్డ్ సిస్టమ్‌లపై ఆధునిక దాడులు ఆధునిక దాడికి, లవణాలు సహాయపడవు.


Modern attacks take advantage of the fact that the hash function being used is easy to compute.

ఆధునిక దాడులు ఉపయోగించబడుతున్న హాష్ ఫంక్షన్ లెక్కించడానికి సులభం అనే వాస్తవాన్ని ఉపయోగించుకుంటాయి.


Salts may make precomputed attacks impossible, but they do very little against an attacker that actually knows the salt.

లవణాలు ముందుగా లెక్కించిన దాడులను అసాధ్యం చేయవచ్చు, కానీ వాస్తవానికి ఉప్పు తెలిసిన దాడి చేసే వ్యక్తికి అవి చాలా తక్కువ చేస్తాయి.


In order to protect passwords, you need a (low-entropy) key derivation function.

పాస్‌వర్డ్‌లను రక్షించడానికి, మీకు (తక్కువ-ఎంట్రోపీ) కీ ఉత్పన్న ఫంక్షన్ అవసరం.


In many hash functions, particularly the previous generations, the internal state kept by the hash function is used as the digest value.

అనేక హాష్ ఫంక్షన్లలో, ముఖ్యంగా మునుపటి తరాలలో, హాష్ ఫంక్షన్ ద్వారా ఉంచబడిన అంతర్గత స్థితి డైజెస్ట్ విలువగా ఉపయోగించబడుతుంది.


If an attacker knows H(M1), it’s very simple to compute H(M1 ‖ M2), without actually knowing the value of M1.

ఒకవేళ దాడి చేసే వ్యక్తి H(M1)ని తెలిస్తే, M1 విలువను వాస్తవంగా తెలుసుకోకుండానే H(M1 ‖ M2)ని లెక్కించడం చాలా సులభం.


The attacker will actually compute H(M1 ‖ G ‖ M2), where G is the glue padding.

దాడి చేసే వ్యక్తి వాస్తవానికి H(M1 ‖ G ‖ M2)ని లెక్కిస్తాడు, ఇక్కడ G అనేది గ్లూ ప్యాడింగ్.


People send messages Mi, authenticated using Ai = H(S ‖ Mi), where S is a shared secret.

ప్రజలు సందేశాలను పంపుతారు Mi, Ai = H(S ‖ Mi)ని ఉపయోగించి ప్రమాణీకరించబడింది, ఇక్కడ S అనేది భాగస్వామ్య రహస్యం.


Because they’re prepended, the internal state of the hash function after processing the prefixes can be computed ahead of time, shaving a few cycles off the MAC computation time.

ముందుగా ఉంచబడినందున, పూర్వపదాలను ప్రాసెస్ చేసిన తర్వాత హాష్ ఫంక్షన్ యొక్క అంతర్గత స్థితిని ముందుగానే లెక్కించవచ్చు, ఇది MAC గణన సమయం నుండి కొన్ని చక్రాలను ఆదా చేస్తుంది.


So far, we’ve always assumed that MAC functions can be used with a single key to produce secure MACs for a very large number of messages.

ఇప్పటివరకు, చాలా పెద్ద సంఖ్యలో సందేశాల కోసం సురక్షితమైన MACలను ఉత్పత్తి చేయడానికి MAC ఫంక్షన్లను ఒకే కీతో ఉపయోగించవచ్చని మేము ఎల్లప్పుడూ భావించాము.


An algorithm that only works once just seems objectively worse.

ఒకేసారి మాత్రమే పనిచేసే అల్గారిథం కేవలం లక్ష్యంగా అధ్వాన్నంగా కనిపిస్తుంది.


They can be incredibly fast to evaluate, even for very large messages.

ఇది చాలా పెద్ద సందేశాల కోసం కూడా అంచనా వేయడానికి చాలా వేగంగా ఉంటుంది.


They have a compelling security proof based on the information content of the tag.

ఇది ట్యాగ్ యొక్క సమాచార విషయాల ఆధారంగా బలవంతపు భద్రతా రుజువును కలిగి ఉంది.


A construction exists to turn a one-time MAC into a secure multiple-use MAC, removing the principal problem.

ఒక-సమయం MACని సురక్షితమైన బహుళ-వినియోగ MACగా మార్చడానికి ఒక నిర్మాణం ఉంది, ఇది ప్రధాన సమస్యను తొలగిస్తుంది.


A typical simple example of such one-time MACs consists of a simple multiplication and addition modulo some large prime p.

అటువంటి ఒక-సమయం MACల యొక్క సాధారణ సాధారణ ఉదాహరణలో కొన్ని పెద్ద ప్రధాన p మాడ్యులో సాధారణ గుణకారం మరియు కూడిక ఉంటాయి.


This simple example only works for one-block messages m, and some prime p slightly bigger than the biggest m.

ఈ సాధారణ ఉదాహరణ ఒక-బ్లాక్ సందేశాల m కోసం మాత్రమే పనిచేస్తుంది మరియు కొన్ని ప్రధాన p, అతిపెద్ద m కంటే కొంచెం పెద్దది.


It can be extended to support bigger messages M consisting of blocks m i by using a message-specific polynomial P:

సందేశ-నిర్దిష్ట పాలీనోమియల్ Pని ఉపయోగించి బ్లాక్‌ల m iతో కూడిన పెద్ద సందేశాలకు M మద్దతు ఇవ్వడానికి దీన్ని పొడిగించవచ్చు:


In many ways, a one-time MAC is to authentication what a one-time pad is to encryption.

అనేక విధాలుగా, ఒక-సమయం MAC అనేది ప్రమాణీకరణకు ఒక-సమయం ప్యాడ్ గుప్తలేఖనానికి సమానంగా ఉంటుంది.


The security argument is similar: as long as the key is only used once, an attacker learns no information about the key or the message, because they are being irreversibly mixed.

భద్రతా వాదన ఇలాగే ఉంది: కీని ఒక్కసారి మాత్రమే ఉపయోగిస్తే, దాడి చేసే వ్యక్తి కీ లేదా సందేశం గురించి ఎటువంటి సమాచారాన్ని పొందలేడు, ఎందుకంటే అవి కోలుకోలేని విధంగా కలపబడతాయి.


This demonstrates that the MAC is secure against attackers trying to produce existential forgeries, even when that attacker has infinite computational power.

అనంతమైన గణన శక్తి ఉన్నప్పటికీ, ఉనికి ఫోర్జరీలను ఉత్పత్తి చేయడానికి ప్రయత్నిస్తున్న దాడి చేసేవారికి వ్యతిరేకంగా MAC సురక్షితంగా ఉందని ఇది చూపిస్తుంది.


Also like a one-time pad, the security argument relies on two very important properties about the keys a, b:

ఒక-సమయం ప్యాడ్ లాగానే, భద్రతా వాదన కీలు a, b గురించి రెండు చాలా ముఖ్యమైన లక్షణాలపై ఆధారపడి ఉంటుంది:


Re-using a and b We’ll illustrate that our example MAC is insecure if it is used to authenticate two messages m 1 , m 2 with the same key(a, b):

a మరియు bని తిరిగి ఉపయోగించడం: ఒకే కీ(a, b)తో రెండు సందేశాలను m 1 , m 2ని ప్రమాణీకరించడానికి ఉపయోగిస్తే, మా ఉదాహరణ MAC సురక్షితం కాదని మేము వివరిస్తాము:


An attacker can reconstruct a, b with some simple modular arithmetic:

కొంత సాధారణ మాడ్యులర్ అంకగణితంతో దాడి చేసే వ్యక్తి a, bని పునర్నిర్మించగలడు:


As you can see, as with one-time pads, re-using the key even once leads to a complete failure of the cryptosystem to preserve privacy or integrity, as the case may be.

మీరు చూడగలిగినట్లుగా, ఒక-సమయం ప్యాడ్‌లతో, కీని ఒక్కసారి కూడా తిరిగి ఉపయోగించడం వలన, సందర్భానుసారంగా, గోప్యత లేదా సమగ్రతను కాపాడటానికి క్రిప్టోసిస్టమ్ పూర్తిగా విఫలమవుతుంది.


Fortunately, this weakness can be solved with a construction called a Carter-Wegman MAC, which we’ll see in the next section.

అదృష్టవశాత్తూ, ఈ బలహీనతను కార్టర్-వెగ్మాన్ MAC అని పిలువబడే నిర్మాణంతో పరిష్కరించవచ్చు, దీనిని మనం తదుపరి విభాగంలో చూస్తాము.


The idea behind a Carter-Wegman MAC is that you can use a one-time MAC O to produce a tag for the bulk of the data, and then encrypt a nonce n with a pseudorandom function F, such as a block cipher, to protect that one-time tag:

కార్టర్-వెగ్మాన్ MAC వెనుక ఉన్న ఆలోచన ఏమిటంటే, మీరు డేటా మొత్తానికి ట్యాగ్‌ను ఉత్పత్తి చేయడానికి ఒక-సమయం MAC Oని ఉపయోగించవచ్చు, ఆపై ఆ ఒక-సమయం ట్యాగ్‌ను రక్షించడానికి బ్లాక్ సైఫర్ వంటి సూడోరాండమ్ ఫంక్షన్ Fతో నాన్స్ nని గుప్తీకరించవచ్చు:


As long as F is a secure pseudorandom function, the nonce’s encryption is totally unpredictable.

F సురక్షితమైన సూడోరాండమ్ ఫంక్షన్ అయినంత కాలం, నాన్స్ యొక్క గుప్తీకరణ పూర్తిగా ఊహించలేనిది.


In the second term, O(k 2 , M), the large input message M is only handled by the very fast one-time MAC O.

రెండవ పదంలో, O(k 2 , M), పెద్ద ఇన్పుట్ సందేశం Mని చాలా వేగవంతమైన ఒక-సమయం MAC O మాత్రమే నిర్వహిస్తుంది.


A state generation function, which produces a new state from the old state.

ఒక రాష్ట్ర ఉత్పత్తి ఫంక్షన్, ఇది పాత రాష్ట్రం నుండి కొత్త రాష్ట్రాన్ని ఉత్పత్తి చేస్తుంది.


The state initialization function is also called right before the first number is extracted.

మొదటి సంఖ్యను సంగ్రహించే ముందు రాష్ట్ర ప్రారంభ ఫంక్షన్ కూడా పిలువబడుతుంది.


The state regeneration function takes the current state and produces a new state.

రాష్ట్ర పునరుత్పత్తి ఫంక్షన్ ప్రస్తుత రాష్ట్రాన్ని తీసుకుని కొత్త రాష్ట్రాన్ని ఉత్పత్తి చేస్తుంది.


The tempering function is applied to the current element of the state before returning it as the produced random number.

ఉత్పత్తి చేయబడిన యాదృచ్ఛిక సంఖ్యగా తిరిగి ఇచ్చే ముందు స్టేట్ యొక్క ప్రస్తుత మూలకానికి టెంపరింగ్ ఫంక్షన్ వర్తించబడుతుంది.


Remember that for cryptographic security, it has to be impossible to predict future outputs or recover past outputs given present outputs.

క్రిప్టోగ్రాఫిక్ భద్రత కోసం, ప్రస్తుత అవుట్‌పుట్‌లను బట్టి భవిష్యత్ అవుట్‌పుట్‌లను అంచనా వేయడం లేదా గత అవుట్‌పుట్‌లను తిరిగి పొందడం అసాధ్యం అని గుర్తుంచుకోండి.


SSL, short for Secure Socket Layer, is a cryptographic protocol originally introduced by Netscape Communications.

SSL, సురక్షిత సాకెట్ లేయర్ యొక్క సంక్షిప్త రూపం, ఇది మొదట నెట్‌స్కేప్ కమ్యూనికేషన్స్ ద్వారా ప్రవేశపెట్టబడిన క్రిప్టోగ్రాఫిక్ ప్రోటోకాల్.


The term SSL is still commonly used, even when the speaker actually means a TLS connection.

స్పీకర్ వాస్తవానికి TLS కనెక్షన్ అని అర్థం అయినప్పటికీ, SSL అనే పదాన్ని ఇప్పటికీ సాధారణంగా ఉపయోగిస్తారు.


Its first and foremost goal is to transport bytes securely, over the Internet or any other insecure medium.

ఇంటర్నెట్ లేదా ఏదైనా ఇతర అసురక్షిత మాధ్యమం ద్వారా, దాని మొదటి మరియు ప్రధాన లక్ష్యం బైట్‌లను సురక్షితంగా రవాణా చేయడం.


TLS is the world’s most common cryptosystem, and hence probably also the most studied.

TLS ప్రపంచంలో అత్యంత సాధారణ క్రిప్టోసిస్టమ్, మరియు అందువల్ల బహుశా అత్యంత అధ్యయనం చేయబడింది.


Over the years, many flaws have been discovered in SSL and TLS, despite many of the world’s top cryptographers contributing to and examining the standard.

సంవత్సరాలుగా, ప్రపంచంలోని అగ్రశ్రేణి క్రిప్టోగ్రాఫర్‌లు ప్రమాణానికి సహకరించినప్పటికీ మరియు పరిశీలించినప్పటికీ, SSL మరియు TLSలో అనేక లోపాలు కనుగొనబడ్డాయి.


A downgrade attack is a man-in-the-middle attack where an attacker modifies the handshake messages.

డౌన్‌గ్రేడ్ దాడి అనేది మ్యాన్-ఇన్-ది-మిడిల్ దాడి, ఇక్కడ దాడి చేసే వ్యక్తి హ్యాండ్‌షేక్ సందేశాలను సవరిస్తాడు.


TLS certificates can be used to authenticate peers, but how do we authenticate the certificate?

TLS సర్టిఫికెట్‌లను సహచరులను ప్రామాణీకరించడానికి ఉపయోగించవచ్చు, కానీ మనం సర్టిఫికేట్‌ను ఎలా ప్రామాణీకరించాలి?


When someone actually tries to use a certificate to impersonate a bank, real browsers don’t believe them.

ఎవరైనా బ్యాంకును అనుకరించడానికి సర్టిఫికేట్‌ను ఉపయోగించడానికి ప్రయత్నించినప్పుడు, నిజమైన బ్రౌజర్‌లు వాటిని నమ్మవు.


They notify the user that the certificate is untrusted.

సర్టిఫికేట్ నమ్మదగినది కాదని వారు వినియోగదారునికి తెలియజేస్తారు.


TLS clients come with a list of trusted certificate authorities.

TLS క్లయింట్‌లు విశ్వసనీయ సర్టిఫికేట్ అధికారుల జాబితాతో వస్తాయి.


The idea is that the certificate authority wouldn’t sign a certificate for Facebook or a bank or anyone else, unless you could prove you’re actually them.

మీరు నిజంగా వారేనని మీరు నిరూపించగలిగితే తప్ప, సర్టిఫికేట్ అధికారం Facebook లేదా బ్యాంకు లేదా మరెవరికీ సర్టిఫికేట్‌ను సంతకం చేయదు.


In TLS, certificates are usually only used to identify the server.

TLSలో, సర్టిఫికెట్‌లను సాధారణంగా సర్వర్‌ను గుర్తించడానికి మాత్రమే ఉపయోగిస్తారు.


The TLS specification explicitly supports client certificates.

TLS స్పెసిఫికేషన్ స్పష్టంగా క్లయింట్ సర్టిఫికెట్‌లకు మద్దతు ఇస్తుంది.


Suppose an attacker gets access to the server’s private key.

ఒక దాడి చేసే వ్యక్తి సర్వర్ యొక్క ప్రైవేట్ కీని యాక్సెస్ చేసాడని అనుకుందాం.


That property is called perfect forward secrecy.

ఆ లక్షణాన్ని పరిపూర్ణ ఫార్వర్డ్ రహస్యత అంటారు.


symmetric-key encryption Seesecret-key encryption.

సమరూప-కీ ఎన్‌క్రిప్షన్ రహస్య-కీ ఎన్‌క్రిప్షన్ చూడండి.


AEAD Authenticated Encryption with Associated Data.

AEAD అనుబంధ డేటాతో ప్రమాణీకరించబడిన ఎన్‌క్రిప్షన్.


AES అధునాతన ఎన్‌క్రిప్షన్ ప్రమాణం.


AKE ప్రమాణీకరించబడిన కీ మార్పిడి.


ARX జోడించు, తిప్పు, XOR.


BEAST SSL/TLSకి వ్యతిరేకంగా బ్రౌజర్ ఎక్స్‌ప్లాయిట్.


CBC సైఫర్ బ్లాక్ చైనింగ్.


CDN కంటెంట్ పంపిణీ నెట్‌వర్క్.


CSPRNG cryptographically secure pseudorandom number generator.

CSPRNG క్రిప్టోగ్రాఫిక్‌గా సురక్షితమైన సూడోరాండమ్ నంబర్ జనరేటర్.


CSRF క్రాస్-సైట్ రిక్వెస్ట్ ఫోర్జరీ.


DES డేటా ఎన్‌క్రిప్షన్ ప్రమాణం.


FIPS Federal Information Processing Standards.

FIPS సమాఖ్య సమాచార ప్రాసెసింగ్ ప్రమాణాలు.


GCM గాల్వాయిస్ కౌంటర్ మోడ్.


HKDF HMAC-based (Extract-and-Expand) Key Derivation Function.

HKDF HMAC-ఆధారిత (ఎక్స్‌ట్రాక్ట్-అండ్-ఎక్స్‌పాండ్) కీ డిరైవేషన్ ఫంక్షన్.


HMAC Hash-based Message Authentication Code.

HMAC హాష్-ఆధారిత సందేశ ప్రమాణీకరణ కోడ్.


HSTS HTTP స్ట్రిక్ట్ ట్రాన్స్‌పోర్ట్ సెక్యూరిటీ.


IV ప్రారంభ వెక్టర్.


KDF కీ డిరైవేషన్ ఫంక్షన్.


MAC సందేశ ప్రమాణీకరణ కోడ్.


MITM మధ్యలో ఉన్న వ్యక్తి.


Browsers originally implemented certificate pinning by coming shipped with a list of certificates from large, high-profile websites.

ప్రారంభంలో, పెద్ద, అత్యంత ప్రొఫైల్ కలిగిన వెబ్‌సైట్‌ల నుండి సర్టిఫికెట్‌ల జాబితాతో బ్రౌజర్‌లు సర్టిఫికెట్ పిన్నింగ్‌ను అమలు చేశాయి.


For example, Google included whitelisted certificates for all of their services in their Chrome browser.

ఉదాహరణకు, గూగుల్ తమ Chrome బ్రౌజర్‌లో తమ అన్ని సేవల కోసం వైట్‌లిస్ట్ చేయబడిన సర్టిఫికెట్‌లను చేర్చింది.


Often, the defaults are unsafe, and people are unaware that they should be changed.

తరచుగా, డిఫాల్ట్‌లు సురక్షితం కాదు మరియు వాటిని మార్చాలని ప్రజలకు తెలియదు.


The things that constitute a secure TLS configuration can change rapidly.

సురక్షిత TLS కాన్ఫిగరేషన్‌ను ఏర్పరిచే విషయాలు వేగంగా మారవచ్చు.


Old clients that still need to be supported sometimes mean that you have to hang on to broken configuration options.

మద్దతు ఇవ్వాల్సిన పాత క్లయింట్‌లు కొన్నిసార్లు మీరు విరిగిన కాన్ఫిగరేషన్ ఎంపికలను కలిగి ఉండాలని అర్థం.


That attack exploited weaknesses in CBC ciphersuites in TLSv1.0.

ఆ దాడి TLSv1.0లో CBC సైఫర్‌సూట్‌లలోని బలహీనతలను ఉపయోగించుకుంది.


Many people recommended defending against it by switching to RC4.

RC4కి మారడం ద్వారా దాని నుండి రక్షించుకోవాలని చాలా మంది సిఫార్సు చేశారు.


Good advice necessarily changes over time, and it’s impossible to do so in a persistent medium such as a book.

మంచి సలహా కాలక్రమేణా మారుతుంది మరియు పుస్తకం వంటి స్థిరమైన మాధ్యమంలో అలా చేయడం అసాధ్యం.


They provide tests for both SSL clients and servers, and extensive advice on how to improve configurations.

వారు SSL క్లయింట్‌లు మరియు సర్వర్‌ల కోసం పరీక్షలను అందిస్తారు మరియు కాన్ఫిగరేషన్‌లను ఎలా మెరుగుపరచాలనే దానిపై విస్తృతమైన సలహాలను అందిస్తారు.


OpenPGP is an open standard that describes a method for encrypting and signing messages.

OpenPGP అనేది సందేశాలను గుప్తీకరించడానికి మరియు సంతకం చేయడానికి ఒక పద్ధతిని వివరించే ఒక ఓపెన్ స్టాండర్డ్.


Unlike TLS, which focuses on data in motion, OpenPGP focuses on data at rest.

చలనంలో ఉన్న డేటాపై దృష్టి సారించే TLS కాకుండా, OpenPGP విశ్రాంతిలో ఉన్న డేటాపై దృష్టి పెడుతుంది.


A TLS session is active: bytes fly back and forth as the peers set up the secure channel.

TLS సెషన్ యాక్టివ్‌గా ఉంటుంది: సహచరులు సురక్షిత ఛానెల్‌ను ఏర్పాటు చేసినప్పుడు బైట్‌లు అటూ ఇటూ ఎగురుతాయి.


An OpenPGP interaction is, by comparison, static: the sender computes the entire message up front using information shared ahead of time.

ఒక OpenPGP పరస్పర చర్య, పోలిక ద్వారా, స్టాటిక్: పంపినవారు ముందుగానే షేర్ చేసిన సమాచారాన్ని ఉపయోగించి మొత్తం సందేశాన్ని ముందుగానే లెక్కిస్తారు.


Users have key pairs consisting of a public key and a private key.

వినియోగదారులకు పబ్లిక్ కీ మరియు ప్రైవేట్ కీతో కూడిన కీ జతలు ఉంటాయి.


Public key algorithms are used both for signing and encryption.

పబ్లిక్ కీ అల్గారిథమ్‌లు సంతకం చేయడానికి మరియు గుప్తీకరించడానికి రెండింటికీ ఉపయోగించబడతాయి.


OpenPGP does not operate using such trusted roots.

OpenPGP అలాంటి విశ్వసనీయ మూలాలను ఉపయోగించి పనిచేయదు.


Instead, it relies on a system called the Web of Trust.

బదులుగా, ఇది వెబ్ ఆఫ్ ట్రస్ట్ అనే వ్యవస్థపై ఆధారపడుతుంది.


The simplest case is a directly trusted key.

అతి సాధారణమైనది నేరుగా విశ్వసించబడిన కీ.


If we meet up in person, we can verify each other’s identities.

మేము వ్యక్తిగతంగా కలిస్తే, ఒకరికొకరు గుర్తింపును ధృవీకరించవచ్చు.


Off-the-record (OTR) messaging is a protocol for securing instant messaging communication between people.

ఆఫ్-ది-రికార్డ్ (OTR) సందేశం అనేది వ్యక్తుల మధ్య తక్షణ సందేశాల కమ్యూనికేషన్‌ను సురక్షితం చేయడానికి ఒక ప్రోటోకాల్.


Modular exponentiation is used in many cryptographic applications.

మాడ్యులర్ ఘాతాంకం అనేక క్రిప్టోగ్రాఫిక్ అనువర్తనాల్లో ఉపయోగించబడుతుంది.


The exponent is the private key d, which is usually more than a thousand bits long.

ఘాతాంకం ప్రైవేట్ కీ d, ఇది సాధారణంగా వెయ్యి బిట్స్ కంటే ఎక్కువ పొడవు ఉంటుంది.


Keep in mind that this method will still leak timing information, so it’s only suitable for offline computation.

ఈ పద్ధతి ఇప్పటికీ సమయ సమాచారాన్ని లీక్ చేస్తుందని గుర్తుంచుకోండి, కాబట్టి ఇది ఆఫ్‌లైన్ గణనలకు మాత్రమే అనుకూలంగా ఉంటుంది.


Modular exponentiation can also be computed using a technique called a Montgomery ladder.

మాడ్యులర్ ఘాతాంకాన్ని మాంటెగోమేరీ నిచ్చెన అని పిలువబడే ఒక సాంకేతికతను ఉపయోగించి కూడా లెక్కించవచ్చు.


Many programming languages provide access to specific modular exponentiation functions.

అనేక ప్రోగ్రామింగ్ భాషలు నిర్దిష్ట మాడ్యులర్ ఘాతాంక ఫంక్షన్లకు ప్రాప్యతను అందిస్తాయి.


For example, in Python, pow(e, x, m) performs efficient modular exponentiation.

ఉదాహరణకు, పైథాన్‌లో, pow(e, x, m) సమర్థవంతమైన మాడ్యులర్ ఘాతాంకాన్ని నిర్వహిస్తుంది.


However, the expression (e ** x) % m will still use the inefficient method.

అయితే, (e ** x) % m అనే వ్యక్తీకరణ ఇప్పటికీ అసమర్థ పద్ధతిని ఉపయోగిస్తుంది.


The Montgomery ladder is an algorithm that resolves this by guaranteeing the same number of operations irrespective of the particular value of the exponent.

మాంటెగోమేరీ నిచ్చెన అనేది ఒక అల్గారిథం, ఇది ఘాతాంకం యొక్క నిర్దిష్ట విలువతో సంబంధం లేకుండా ఒకే సంఖ్యలో కార్యకలాపాలను హామీ ఇవ్వడం ద్వారా దీన్ని పరిష్కరిస్తుంది.


It was originally applied for efficient scalar multiplications over elliptic curves.

ఇది మొదట ఎలిప్టిక్ వక్రాలపై సమర్థవంతమైన స్కేలార్ గుణకారాల కోసం వర్తించబడింది.


The mathematics works for many other systems: specifically, for any abelian group.

గణితం అనేక ఇతర వ్యవస్థలకు పని చేస్తుంది: ప్రత్యేకంగా, ఏదైనా అబెలియన్ సమూహం కోసం.


This section involves a good deal of arithmetic tricks.

ఈ విభాగంలో చాలా అంకగణిత ఉపాయాలు ఉన్నాయి.


You might want to get out some paper and pencil to follow along.

మీరు అనుసరించడానికి కొన్ని కాగితం మరియు పెన్సిల్‌ను బయటకు తీయవచ్చు.


Like with exponentiation by squaring, we start by looking at the binary expansion of the exponent k.

వర్గీకరణ ద్వారా ఘాతాంకం వలె, మేము ఘాతాంకం k యొక్క బైనరీ విస్తరణను పరిశీలించడం ద్వారా ప్రారంభిస్తాము.


Generally, any k can be written as a sum ( ∑ ) of some powers of two (2 i ).

సాధారణంగా, ఏదైనా k ని రెండు యొక్క కొన్ని శక్తుల ( ∑ ) మొత్తం (2 i )గా వ్రాయవచ్చు.


That definition might look scary, but all you’re really doing here is defining k i as bit of k at position i.

ఆ నిర్వచనం భయానకంగా అనిపించవచ్చు, కానీ మీరు ఇక్కడ నిజంగా చేస్తున్నది ఏమిటంటే k i ని స్థానం i వద్ద k యొక్క బిట్‌గా నిర్వచించడం.


The sum goes over all the bits: if k is t bits long, and we start indexing at 0, the index of the highest bit is t−1, and the index of the lowest bit is 0.

మొత్తం అన్ని బిట్‌లపైకి వెళుతుంది: k అనేది t బిట్‌ల పొడవుగా ఉంటే, మరియు మేము 0 వద్ద ఇండెక్సింగ్ ప్రారంభించినట్లయితే, అత్యధిక బిట్ యొక్క సూచిక t−1, మరియు అతి తక్కువ బిట్ యొక్క సూచిక 0.


For example, the binary expansion of the number 6 is 0b110.

ఉదాహరణకు, 6 సంఖ్య యొక్క బైనరీ విస్తరణ 0b110.


That number is three bits long, so t = 3.

ఆ సంఖ్య మూడు బిట్‌ల పొడవు, కాబట్టి t = 3.


The next few steps don’t make a lot of sense until you see them come together at the end, so bear with me and check that the math works out.

చివరిలో మీరు వాటిని కలిసి చూసే వరకు తదుపరి కొన్ని దశలు పెద్దగా అర్థం కావు, కాబట్టి నాతో ఉండండి మరియు గణితం పనిచేస్తుందో లేదో తనిఖీ చేయండి.


We’ll define a related sum, L j : L j = t−1 ∑ i=j 2 i−j k i

మేము సంబంధిత మొత్తం, L j ని నిర్వచిస్తాము: L j = t−1 ∑ i=j 2 i−j k i