Die Theorie der Struktur versteckter Systeme

Einführung

Beginnend mit der klassischen Kryptographie, von ihren Anfängen bis zu ihrer Wiedergeburt in die moderne Kryptographie, gab es immer ein Problem bei der Übertragung eines Verschlüsselungsschlüssels zwischen Subjekten. Das Problem wurde teilweise in der zweiten Hälfte des 20. Jahrhunderts gelöst, als ein asymmetrischer Teil der Kryptographie entstand, als ein Abhörangriff unmöglich wurde [1]. Trotzdem bleibt das ursprüngliche Problem bestehen und wird bis heute ausgenutzt, wenn auch in verschleierter Form.

Das Hindernis für die Lösung des Problems liegt im Element des Vertrauens, in seiner Gegenwart und in seiner Abwesenheit. Wenn Sie keine Maßnahmen ergreifen, um vertrauenswürdige Verbindungen herzustellen, sind alle Verbindungen a priori MITM-Angriffen (Man in the Middle) ausgesetzt. Wenn Sie dagegen vertrauenswürdige Verbindungen herstellen, verschwindet die Möglichkeit von MITM-Angriffen nicht, sondern nimmt ab. Und jetzt gibt es neben den ursprünglichen Subjekten zwischengeschaltete Interstitial-Subjekte (Server, Knoten zum Speichern und Übertragen von Informationen), die von uns ausgewählt wurden und rechtmäßig etablierte Angreifer sind. Nur durch die Begrenzung der Angriffsreichweite hören sie nicht auf, potenziell anzugreifen. Diese Knoten kennen alle von uns und an uns übermittelten Informationen: Hobbys, Interessen, Hobbys, Unterhaltung, Nachrichten. Ferner ist diese Information (Objekt), wie so oft,beginnt sich in Werbung umzuwandeln, auf deren Grundlage sich das Kapital aller gleichen Zwischenunternehmen erhöht. Infolgedessen wird das gesamte Problem vollständig auf den Kopf gestellt, und jetzt, anstatt nach einer Verbindung zum Abhören zu suchen, erstellt der Angreifer diese selbst. Er selbst wird zur Grundlage für das Abhören in Form eines Servers und von Personen Wählen Sie nur das Gesicht desjenigen, der dahinter steht. Sie werden genau beobachtet.

Es ist nicht möglich, ein solches Vertrauenssystem zu zerstören, da allgemeinere und destruktivere Arten von Angriffen auftreten und das Vertrauen als solches nicht vollständig beseitigt werden kann [2, S.267]. Alles, was bleibt, ist, dieses System zu verbessern, es so zu gestalten, dass sein Mechanismus selbst dazu neigt, die Vertrauenskraft * zu verringern, so dass seine eigene Struktur den Schutz von Objekten und anonymen Subjekten darstellt. Systeme dieser Art umfassen anonyme Netzwerke und verdeckte Kommunikationskanäle.

, , – , . , , – , , , . /, . , .

, , (, ). , , , . , .

, , . ( - ) , , . , . , . , , , , .

, , . , . : , . “ ” ( ), - . , . “ ” ( ), . , “” , (-) .

, . , , / . , . , / , , , , . , .

- , , , , . (2,3,4,5,6 ).

1. |A| = 0*. .

   
   
   
   
   

2. -, -. , (, IP-, , ). . , , , , - . , , |A| = 1. -.

   
   
   
   
   

3. , , - . , , , lim|A|→C, C - - . , . , ( ) - , - , .

   
   
   
   
   

4. . , , , , , . , , ( ) . , , , [3] .., ( , ). , , , , , , - , [4, .398]. , , , . , ( ) () () . , - 0 < |A| ≤ N, N - . , , , .

   
   
   
   
   

5. , , . . , lim|A|→C, C - . , Tor ( ), I2P ( ) ..

   
   
   
   
   

6. , , , ( ) . , , . 0 < |A| ≤ N(C+1), N - , C - . , , . , , , .

   
   
   
   
   

, , , , , , - .

, , , [5, .223]. , , , , , . , . , , . , .

, , ( ), , , ( ). , , ( , ) . , , . , , , , , (lim|A|→1) . , , , , . , , . , . , . , . , , . :

1. . , . , , , , , . -- ( friend-to-friend), — . , , , . , , - , - . , , , , , , . friend-to-friend (f2f) , , , .

   
   
   
   
   

2. — . , , , () / (). , - , , . , . O(N) . , , N , N-1 . (TTL) , , , , .

   
   
   
   
   

, , , . , . , , , , , . , . , , :

1. — , . , . , . , , , .

   
   
   
   
   

2. . , - . , , A B, A**. Tor, , “”, .

   
   
   
   
   

. , , . , . , , , . , . , . , , , — , “” . , , . , , - -.

import (
	"bytes"
)
func RoutePackage(sender *PrivateKey, receiver *PublicKey, data []byte, route []*PublicKey) *Package { 
  var ( 
    rpack = Encrypt(sender, receiver, data) 
    psender = GenerateKey(N) 
  ) 
  for _, pub := range route { 
    rpack = Encrypt( 
      psender, 
      pub, 
      bytes.Join(
        [][]byte{
          ROUTE_MODE, 
          SerializePackage(rpack),
        },
        []byte{},
      ),
    )
  } 
  return rpack 
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, {A, B, C} ( — A) , , ( , ). , , , , , . , , , : (A → B A → C) → (B → C C → B) → (B → A C → A), , : (A → B A → C) → (B → A C → A)***. , (), . , ( , ), ( , ). , , , , , : (1) - (1) - (2) (1) - (1) - (1). , ( ), (2) (2), . , ( ) k n ( n = 2), (k, 2) = 2 ( — ), , k = 2, : (A → B A → C) → (B → C C → B) → (B → C C → B) → (B → A C → A). , : (1) - (1) - (2) - (2) (1) - (1) - (~1) - (1), . , (1) = (1), (2) = (1), (2) = (~1). (1), , . - , . , (3) = (2), .

, , , , . , , - , - , - - . , . , :

1. . , , . , . , , .

   
   
   
   
   

2. . , , , , , . , .

   
   
   
   
   

, , , , ( ). T, (2+k, 2) ( - ), , k = 2 4. , , , ( ). , , , , . :

1. k ( , ).

   
   
   
   
   

   

2. k [1;n], n < N ( ).

   
   
   
   
   

   

* — , , , . , ( ). , ( ).

, , - , , , . , , , , - . , :

1. , , - , / [7] . , , (, ), (). (), .

   
   
   
   
   

2. , , , , . , , . , . , , , . ( |A| = 1), . , , . , , , , . - — ( ).

   
   
   
   
   

, , , . , , , . , , , , . , -, -, , , . , . , ( , ) 2MiB, 256KiB.

, , . , , , . , , (, ..), , . , , , . , , .

, , , . , , . , ( , , ), , .

, , , , , [8, .720]. , , , , , . , , , . , - , .

, , ( ), , ( ), ( ) ( , ).

, , , , . [2, .58][8, .80].

. , , , , , .

, . , , . . . .

, , , , , , - , . , , ( , ) .

import ( 
  "bytes" 
  "encoding/hex" 
) 
func Encrypt(sender *PrivateKey, receiver *PublicKey, data []byte) *Package { 
  var ( 
    session = GenerateBytes(N) 
    rand = GenerateBytes(M) 
    pubsend = PublicKeyToBytes(&sender.PublicKey) 
    hash = HashSum(bytes.Join( 
      [][]byte{ 
        rand, 
        data,pubsend, 
        PublicKeyToBytes(receiver), 
      }, 
      []byte{}, 
    )) 
    sign = Sign(sender, hash) 
  ) 
  return &Package{ 
    Head: HeadPackage{ 
      Rand: hex.EncodeToString(EncryptS(session, rand)), 
      Sender: hex.EncodeToString(EncryptS(session, pubsend)), 
      Session: hex.EncodeToString(EncryptA(receiver, session)), 
    }, Body: BodyPackage{ 
      Data: hex.EncodeToString(EncryptS(session, data)), 
      Hash: hex.EncodeToString(hash), 
      Sign: hex.EncodeToString(EncryptS(session, sign)), 
      Npow: ProofOfWork(hash, C), 
    }, 
  } 
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, , ( ) . , .

() , , , .

import ( 
  "bytes" 
  "encoding/hex" 
) 
func Decrypt(receiver *PrivateKey, pack *Package) (*PublicKey, []byte) { 
  // Check proof. 
  hash, err := hex.DecodeString(pack.Body.Hash) 
  if err != nil { 
    return nil, nil 
  } 
  if !ProofIsValid(hash, C, pack.Body.Npow) { 
    return nil, nil 
  } 
  // Decrypt session key. 
  eskey, err := hex.DecodeString(pack.Head.Session) 
  if err != nil { 
    return nil, nil 
  } 
  skey := DecryptA(receiver, eskey) 
  if skey == nil { 
    return nil, nil 
  } 
  // Decrypt public key.
  ebpubsend, err := hex.DecodeString(pack.Head.Sender) 
  if err != nil { 
    return nil, nil 
  } 
  bpubsend := DecryptS(skey, ebpubsend) 
  if bpubsend == nil { 
    return nil, nil 
  } 
  pubsend := BytesToPublicKey(bpubsend) 
  if pubsend == nil { 
    return nil, nil 
  } 
  // Decrypt and check sign. 
  esign, err := hex.DecodeString(pack.Body.Sign) 
  if err != nil { 
    return nil, nil 
  } 
  sign := DecryptS(skey, esign) 
  if sign == nil { 
    return nil, nil 
  } 
  if !Verify(pubsend, hash, sign) { 
    return nil, nil 
  } 
  // Decrypt rand. 
  erand, err := hex.DecodeString(pack.Head.Rand) 
  if err != nil { 
    return nil, nil 
  }
  rand := DecryptS(skey, erand) 
  if rand == nil { 
    return nil, nil 
  } 
  // Decrypt data. 
  edata, err := hex.DecodeString(pack.Body.Data) 
  if err != nil { 
    return nil, nil 
  } 
  data := DecryptS(skey, edata) 
  if data == nil { 
    return nil, nil 
  } 
  // Check hash. 
  check := HashSum(bytes.Join( 
    [][]byte{ 
      rand, 
      data, 
      PublicKeyToBytes(pubsend), 
      PublicKeyToBytes(&receiver.PublicKey), 
    }, 
    []byte{}, 
  )) 
  if !bytes.Equal(hash, check) { 
    return nil, nil 
  } 
  return pubsend, data 
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, , , , ( ), n- , i- . , ⎡M/nN⎤+1 , M - , N - . , , .

, ( , ), , ( ) ( ). , . . , , . , , (, ), (, ) ( , ). ( ), .

1. . ., . . [ ]. — : https://ee.stanford.edu/~hellman/publications/24.pdf ( : 19.12.2020).

   
   
   
   
   

2. , ., , . . / . , . . . - .: «, 2005. - 420 .

   
   
   
   
   

3. , . : [ ]. — : https://bitcoin.org/files/bitcoin-paper/bitcoin_ru.pdf ( : 19.12.2020).

   
   
   
   
   

4. , ., , . / . , . . — .: , 2017. - 960 .

   
   
   
   
   

5. , . ., , . . / . . , . . . - .: - , 2019. - 300 .

   
   
   
   
   

6. Donovan, A.A., Kernighan, B.U. Gehen Sie zur Programmiersprache / A.A. Donovan, B.U. Kernighan. - M.: OOO "I.D. Williams ", 2018. - 432 p.

   
   
   
   
   

7. Shelukhin, O. I., Kanaev, S. D. Steganographie. Algorithmen und Software-Implementierung / O.I. Shelukhin, S.D. Kanaev. - M.: Hotline - Telecom, 2018 .-- 592 p.

   
   
   
   
   

8. Schneier, B. Angewandte Kryptographie. Protokolle, Algorithmen und Quellcodes in C / B. Schneier. - SPB .: OOO "Alfa-kniga", 2018. - 1040 p.