La théorie de la structure des systèmes cachés

introduction

À partir de la cryptographie classique, de sa création à sa renaissance dans la cryptographie moderne, il y a toujours eu un problème de transfert d'une clé de cryptage entre sujets. Le problème a été partiellement résolu dans la seconde moitié du XXe siècle, avec l'émergence d'une section asymétrique de la cryptographie, lorsqu'une attaque d'écoute est devenue impossible [1]. Néanmoins, le problème originel demeure et est encore exploité à ce jour, quoique sous une forme voilée.

L'obstacle qui est devenu sur la solution du problème réside dans l'élément de confiance, en sa présence et en son absence. Si vous ne prenez aucune mesure pour établir des connexions de confiance, alors toutes les connexions feront a priori l'objet d'attaques MITM (man in the middle). D'un autre côté, si vous établissez des connexions de confiance, la possibilité d'attaques MITM ne disparaît pas, mais diminue. Et maintenant, avec les sujets originaux, il y a des sujets intermédiaires, interstitiels (serveurs, nœuds pour stocker et transmettre des informations), choisis par nous, et sont des attaquants légalement établis. Ce n'est qu'en limitant la portée d'attaque qu'ils n'arrêtent pas d'attaquer potentiellement. Ces nœuds connaissent toutes les informations transmises par nous et à nous: passe-temps, intérêts, passe-temps, divertissement, messages. De plus, cette information (objet), comme cela arrive souvent,commence à se convertir en publicité, sur la base de laquelle le capital de toutes les mêmes entités intermédiaires augmente. En conséquence, tout le problème est complètement bouleversé, et maintenant, au lieu de chercher une connexion pour l'écoute clandestine, l'attaquant la crée lui-même, il devient lui-même le fondement de l'écoute sous l'apparence d'un serveur, et les gens, à leur tour , ne choisissez que le visage de celui qui est derrière ils seront surveillés de près.

Il n'est pas possible de détruire un tel système de confiance en raison de l'émergence de types d'attaques plus généraux et destructeurs, ainsi qu'en raison de l'impossibilité d'éradiquer complètement la confiance en tant que telle [2, p.267]. Ainsi, il ne reste plus qu'à améliorer ce système, à faire en sorte que son mécanisme lui-même tende à réduire le pouvoir de confiance *, de sorte que sa propre structure représenterait la protection des objets et des sujets anonymes. Les systèmes de ce type comprennent des réseaux anonymes et des canaux de communication secrets.

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

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

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

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

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

- , , , , . (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. Aller au langage de programmation / A.A. Donovan, B.U. Kernighan. - M.: OOO "I.D. Williams ", 2018. - 432 p.

   
   
   
   
   

7. Shelukhin, O. I., Kanaev, S. D. Stéganographie. Algorithmes et implémentation logicielle / O.I. Shelukhin, S.D. Kanaev. - M .: Hotline - Telecom, 2018 - 592 p.

   
   
   
   
   

8. Schneier, B. Cryptographie appliquée. Protocoles, algorithmes et codes sources en C / B. Schneier. - SPB.: OOO "Alfa-kniga", 2018. - 1040 p.