#1
  1. No Profile Picture
    Registered User
    Devshed Newbie (0 - 499 posts)

    Join Date
    Mar 2012
    Posts
    3
    Rep Power
    0

    Public key algorithm


    Hi,

    I've build a small site with an experimental asymmetric encryption algorithm. I've tried to contact to different people without result, so I post it here in the hope more people looks at it.

    It's experimental and needs cryptanalysis, but the key sizes and amount of information needed to perform key agreement and document signature can be really small.

    The description is at:

    www dot asymmetricscrambler dot ezhostingx dot com (no URL since I'm a new user...)

    If you want a quick glance to start criticizing it go straight to the 'Network-like brief description'.

    I'll appreciate support and contributions.

    Best regards
    Daniel
  2. #2
  3. No Profile Picture
    Registered User
    Devshed Newbie (0 - 499 posts)

    Join Date
    Mar 2012
    Posts
    3
    Rep Power
    0

    More information


    Ok :) Let's return to the oooold ansi times. As long as I can post an image with the network description I will do in ascii. The network follows:


    Code:
      I                       V
      |                       |
      |              +--------+ P: Permute bits
    +---+            |        | output[p]=input[(p*(N-1)/2)mod N]
    | P |  +---+-----------+  |
    +---+  |   |           |  | R:Rotation matrix
      |    |   |           |  | First row filled with input
      +----| K |     R     |  | Each row is the preceding 
      k1   |   |           |  | rotated right one position
           |   |           |  | Output: xor of rows where
           +---+-----------+  | bit in K is 1 (lsb on top)
                     |        |
      +--------------+        | Key agreement:
      |                       | Va=X(I,a),Vb=X(I,b)
      |                       | r=X(Va,X(b,I))
      |              +--------+ r=X(Vb,X(a,I))
    +---+            |        | Secret values are a, b
    | P |  +---+-----------+  | Transmitted values are Va, Vb
    +---+  |   |           |  |
      |    |   |           |  | Hash signature:
      +----| K |     R     |  | s=X(H,J), H=hash to sign
      k2   |   |           |  | Check:
           |   |           |  | X(X(I,a),s)=X(X(I,H),X(a,J))
           +---+-----------+  | Secret value is J
                     |        | Public values are X(a,J),x(I,a)
      +--------------+        |
      |                       | N safe prime, n=N/log2(N)
      .                       . each line is N bits wide
      .                       .
      .                       .
      |                       |
      |              +--------+
    +---+            |        
    | P |  +---+-----------+  
    +---+  |   |           |  
      |    |   |           |  
      +----| K |     R     |  
      kn   |   |           |  
           |   |           |  
           +---+-----------+  
                     |        
                     |
                     C
    X(I,V)=C
    
    
    (c) Daniel Nager - daniel.nager at gmail.com
    I've inserted a link because the mathematical description, thoght it's not really complex is 5 pages long. In the address avove there are just documents, it's not a forum nor even a blog, so I wanted to discuss the algorigthm here, and give it some dissemination if possible.

    It's experimental, but the goal is to have N-bit security with N-bit transmissions in a key agreement, not N/2-bit security. So perhaps 83 bits will be safe, even 59 will be extremely hard to break.

    Best regards
    Daniel
  4. #3
  5. No Profile Picture
    Registered User
    Devshed Newbie (0 - 499 posts)

    Join Date
    Mar 2012
    Posts
    3
    Rep Power
    0

    Pseudocode


    Here is the explanation in pseudocode:

    Code:
    N number of bits
    
    Y:
    input a,b
    output r
    
    	r=0 ; all bits 0
    	for i in 0..N-1 do
    		if bit(a,(i*(N-1)/2)mod N)=1 then
    			r=xor(r,b)
    		endif
    		b=ror(b) ; bitwise rotate right
    	endfor
    end Y
    
    X:
    input b, a
    output r
    
    	r=b
    	for i in 0..n-1 do
    		r=Y(r,a)
    	endfor
    
    end X
    
    a and b are N bit arrays, n is the number of rounds
    
    The following holds:
    X(X(I,a),X(b,I))=X(X(I,b),X(a,I))
    where I is an arbitrary N-bit array and a,b the secret values
    of each part.
    
    In a diffie-hellman like key agreement Va=X(I,a) and Vb=X(I,b) is
    sent in each direction and the secret key is calculated 
    k=X(Va,X(b,I))=X(Vb,X(a,I))
    Daniel

IMN logo majestic logo threadwatch logo seochat tools logo