KR100427672B1

KR100427672B1 - 시프트 레지스터의 소프트웨어 구현 방법

Info

Publication number: KR100427672B1
Application number: KR10-2001-0071307A
Authority: KR
Inventors: 한대완; 한재우
Original assignee: 한국전자통신연구원
Priority date: 2001-11-16
Filing date: 2001-11-16
Publication date: 2004-04-28
Also published as: KR20030039913A

Abstract

본 발명은 스트림 암호의 대표적인 생성 논리로 이용되는 LFSR(Linear Feedback Shift Register)과 FCSR(Feedback Carry Shift Register)를 소프트웨어로 구현하기 위한 알고리즘에 관한 것으로, 알고리즘 구현 속도를 향상시키며 메모리의 효율적인 사용이 이루어지도록 한다.

Description

시프트 레지스터의 소프트웨어 구현 방법 {Method for embodying a shift register in software}

본 발명은 시프트 레지스터를 소프트웨어로 구현하기 위한 방법에 관한 것으로, 특히, 스트림 암호의 대표적인 생성 논리로 이용되는 LFSR과 FCSR의 소프트웨어 구현 방법에 관한 것이다.

LFSR(Linear Feedback Shift Register)과 FCSR(Feedback Carry Shift Register)는 스트림 암호를 대표하는 논리들이며, 간단한 구조와 함께 높은 주기를 수학적으로 보장해 주기 때문에 많은 분야에서 사용된다. LFSR과 FCSR는 하드웨어로 구현 시 적은 게이트 복잡도를 가지면서 하나의 클록에 1 비트의 출력을 얻을 수 있어 매우 효율적이라고 알려져 있지만, 소프트웨어로 구현 시에는 각각의 비트들을 반복적으로 이동시키는 과정을 포함하고 있어 매우 느린 속도를 보일 뿐 아니라, 1 비트의 정보를 표현하는 데 있어 최소한 8 비트의 자료 구조를 사용해야 하기 때문에 메모리의 낭비가 심한 단점을 가진다.

그러면 LFSR과 FCSR의 기본 논리를 설명하면 다음과 같다.

LFSR의 기본 논리

유한 체 GF(2) 위에 정의된 n차의 LFSR는 GF(2) 위의 n차 원시 다항식인 하기의 수학식 1로부터 생성된다.

주어진 초기치 n 비트로부터 연속된 2ⁿ-1 비트의 출력을 얻을 수 있으며, k번째 비트는 이전의 n 비트로부터 얻을 수 있다. 즉, 하기의 수학식 2와 같은 관계를 만족한다.

여기에서,는 비트별 배타적 논리합(XOR) 연산을 의미하며, LFSR의 동작 방식은 도 1과 같이 표현된다.

그러면 상기 수학식 1의 원시 다항식 f(x)에 의해 생성되는 LFSR를 소프트웨어로 구현하기 위한 종래의 알고리즘을 도 2를 통해 설명하면 다음과 같다.

LFSR를 소프트웨어로 구현하기 위한 종래의 알고리즘은 크게 4 단계로 이루어진다.

[알고리즘 1] LFSR를 소프트웨어로 구현하기 위한 종래의 알고리즘

단계 1(변수 선언) : n개의 LFSR 값을 저장할 크기 n인 배열 A[]와 새로운 값을 계산하여 저장할 템프(Temp) 변수를 선언한다.

단계 2(초기값 할당) : 배열 A[]에 LFSR의 n개의 초기값을 할당한다. 이 부분은 변수 선언 부분과 더불어 출력 수열의 수에 관계없이 한 번만 수행된다.

단계 3(새로운 값 계산) : 상기 수학식 2로부터 새로운 항을 생성하여 템프 변수에 저장한다.

단계 4(변수 치환) : 도 1에 도시된 바와 같이 새로운 LFSR의레지스터(Register)를 갱신하기 위하여 배열 A[]에 저장된 값들을 한 항씩 이동시키고, 마지막 A[n-1]번째 항에 새로운 값 템프(Temp)를 저장한다.

단계 5: 상기 단계 4 (변수 치환) 과정이 종료되면 새로운 LFSR 1 비트가 생성되는데, 원하는 비트의 출력을 얻기 위하여 상기 단계 3 및 4의 과정을 반복 진행한다.

그런데 상기와 같은 종래의 알고리즘을 사용하게 되면 상기 단계 1에서 원시 다항식의 차수 만큼의 변수를 선언하여야 한다. 그러므로 LFSR 한 항의 실제 정보량은 1 비트이지만, 대부분의 프로그램 언어에서는 최소 8 비트의 크기를 가지는 데이터 구조에 저장할 수 밖에 없기 때문에 메모리의 낭비가 많아진다. 또한, 상기 단계 4에서 LFSR 1 비트를 생성하기 위하여 원시 다항식의 차수 만큼의 변수 치환이 이루어져야 하는데, 원시 다항식의 차수가 보통 100 정도인 것을 감안하면 매우 비효율적이라는 것을 알 수 있다.

FCSR의 기본 논리

2가 아닌 소수(Prime number) q에 대하여 하기의 수학식 3과 같이 이진 전개가 주어졌다면, 이때, q를 연결수로 하는 FCSR는 r개의 레지스터와 메모리 m으로 구성된다.

`

레지스터의 값이이라 하고 메모리를이라 하면 시각 k에서 FCSR의 생성 방식은 도 3과 같이 표현된다.

단계 10: 하기의 수학식 4와 같은 관계식으로 정수합을 구한다.

단계 11: 레지스터의 내용을 오른쪽으로 한칸씩 이동시킨다.

단계 12:(mod 2)를 시프트 레지스터의 최상위 레지스터에 대치시킨다.

단계 13: 메모리을로 바꾼다.

그러면 상기 수학식 3의 연결수 q에 의해 생성되는 FCSR를 소프트웨어로 구현하기 위한 종래의 알고리즘을 도 4를 통해 설명하기로 한다.

FCSR를 소프트웨어로 구현하기 위한 종래의 알고리즘은 크게 5 단계로 이루어진다.

[알고리즘 2] FCSR를 소프트웨어로 구현하기 위한 종래의 알고리즘

단계 20(변수 선언) : n개의 FCSR 값을 저장할 크기 n인 배열 A[]와 새로운 값을 계산하여 저장할 템프(Temp) 변수 및 메모리 변수 M을 선언한다.

단계 21(초기값 할당) : 배열 A[]에 FCSR의 n개의 초기값을, 변수 M에 초기 메모리값을 할당한다.

단계 22(새로운 값 계산) : 상기 수학식 4와 같은 관계식으로부터 새로운항을 생성하여 템프(Temp) 변수에 저장한다.

단계 23(변수 치환) : 도 3에서와 같이 새로운 FCSR의 레지스터를 갱신하기 위하여 배열 A[]에 저장된 값들을 한 항씩 이동시킨다.

단계 24(새로운 항 계산 및 M값 갱신) : A[n-1] = Temp (mod 2)를 계산하고, M = ( Temp - A[n-1]) / 2 를 계산한다.

단계 25: 상기 단계 24 (새로운 항 계산 및 M값 갱신) 과정이 완료되면 새로운 FCSR 1 비트가 A[n-1]에 생성되게 되는데, 원하는 비트의 출력을 얻을 때까지 상기 단계 22 내지 24의 과정을 반복 진행한다.

그러나 상술한 바와 같은 종래의 방법을 사용하면 LFSR의 경우와 마찬가지로 메모리의 낭비가 많아지며, 비효율적인 반복문을 사용해야 하는 단점이 있다.

따라서 본 발명은 불필요한 메모리의 낭비와 원시 다항식의 차수만큼 소요되었던 반복문의 횟수를 감소시키므로써 상기한 단점을 해소할 수 있는 속도가 빠른 LFSR과 FCSR의 소프트웨어 구현 방법을 제공하는 데 그 목적이 있다.

상기한 목적을 달성하기 위한 본 발명에 따른 시프트 레지스터의 소프트웨어 구현 방법은 변수의 갯수(k)를 계산한 후 n개의 LFSR 값을 저장하기 위한 변수와 새로운 값을 계산하여 저장할 템프를 선언하고 임시변수를 선언하는 제 1 단계와, 초기값으로 주어진 n개의 값을 LFSR 값을 저장하기 위한 변수에 대입하여 저장한 후 남은 변수의 왼쪽 메모리 부분을 0으로 채우는 제 2 단계와, n개의 LFSR 값을 저장하기 위한 변수를 메모리 시프트 연산과 비트별 배타적 논리합 연산을 이용하여 임시변수의 메모리에 순차적으로 저장한 후 n개의 LFSR 값을 저장하기 위한 변수를 조합하여 임시변수의 메모리에 순차적으로 저장하는 제 3 단계와, n개의 LFSR 값을 저장하기 위한 템프를 계산하는 제 4 단계와, 새로운 LFSR 값들을 갱신하기 위하여 변수 치환을 실시하는 제 5 단계와, 원하는 비트의 출력을 얻을 때까지 제 3 내지 제 5 단계의 과정을 반복 진행하는 제 6 단계를 포함하여 이루어지는 것을 특징으로 한다.

또한, 본 발명에 따른 다른 시프트 레지스터의 소프트웨어 구현 방법은 변수의 갯수(k)를 계산한 후 n개의 FCSR 값을 저장하기 위한 변수와 메모리 값을 저장할 메모리 변수 및 새로운 값을 계산하여 저장할 임시 변수들을 선언하고 n개의 FCSR 값을 저장하기 위한 변수에 저장된 값들을 분할하여 저장할 때 필요한 변수를 선언하는 제 1 단계와, 초기값으로 주어진 n개의 값을 n개의 FCSR 값을 저장하기 위한 변수에 대입하여 저장하고 남은 변수의 왼쪽 메모리 부분을 0으로 채운 다음 초기값으로 주어진 메모리값을 메모리 변수에 저장하고 메모리 변수를 왼쪽으로 메모리 시프트시키는 제 2 단계와, 초기변수에 저장된 초기값을 네 개의 변수로 분할하여 저장하는 제 3 단계와, 제 3 단계에서 생성된 분할된 변수들을 이용하여 LFSR의 임시변수를 계산한 후 계산된 임시변수를 정수연산으로 더하여 저장하는 제 4 단계와, FCSR의 새로운 항을 생성하기 위하여 전 항에서 갱신된 메모리를 정수합에 더해주는 과정을 임시변수들에 저장된 변수에 대해 순차적으로 진행하는 제 5 단계와, 각각의 정수합이 저장된 메모리 중 오른 쪽에서 두번째의 값을 메모리 값으로 갱신하는 제 6 단계와, 새로운 32 비트 FCSR 값을 얻고난 후 다음 32 비트를 얻기 위하여 변수를 치환하는 제 7 단계와, 원하는 비트의 출력을 얻을 때까지 제 4 단계 및 제 7 단계의 과정을 반복 실시하는 제 8 단계를 포함하여 이루어지는 것을 특징으로 한다.

도 1은 LFSR의 동작 방식을 도시한 생성 구조도.

도 2는 LFSR의 소프트웨어를 구현하기 위한 종래 알고리즘의 흐름도.

도 3은 FCSR의 동작 방식을 도시한 생성 구조도.

도 4는 FCSR의 소프트웨어를 구현하기 위한 종래 알고리즘의 흐름도.

도 5는 본 발명에 따른 LFSR의 소프트웨어 구현 방법을 설명하기 위한 흐름도.

도 6은 본 발명의 알고리즘을 특정한 LFSR의 소프트웨어 구현에 적용했을 경우 메모리의 상태도.

도 7은 본 발명에 따른 FCSR의 소프트웨어 구현 방법을 설명하기 위한 흐름도.

도 8은 도 7의 단계 42를 설명하기 위한 예시도.

도 9는 도 7의 단계 44를 설명하기 위한 흐름도.

본 발명은 32 비트 자료형 변수에 32개의 정보를 담아 1회의 알고리즘 동작으로 LFSR 및 FCSR를 32 비트씩 생성하고 반복문의 횟수도 획기적으로 감소시킨다. 그러면 본 발명에서 제시하는 LFSR과 FCSR의 소프트웨어 구현 알고리즘을 첨부된 도면을 참조하여 상세히 설명하기로 한다.

도 5는 본 발명에 따른 LFSR의 소프트웨어 구현 방법을 설명하기 위한 흐름도이다.

LFSR를 생성하는 원시 다항식의 차(degree)수가 n이고 단(tap) 수가 t라고 하자. 설명의 편의를 위하여 상기 수학식 1의 원시 다항식을 계수가 0이 아닌 항의 합만으로 표현하면 하기의 수학식 5와 같다.

(0 = n₁< n₂< ..... < n_t=n)

그러면, 상기 수학식 5에 의해 생성되는 LFSR {a_i}의 관계식은 하기의 수학식 6과 같이 표현된다.

(k = 0, 1, 2,....)

[알고리즘 3] LFSR를 소프트웨어로 구현하기 위한 본 발명의 알고리즘

단계 30: 변수 선언

①을 계산한다.

n개의 LFSR 값을 저장하기 위한 변수의 갯수를 계산한다. [a]는 a보다 같거나 작은 최대 정수를 의미한다. n개의 LFSR 값을 한 변수에 32개씩 저장할 것이므로, k개 만큼의 변수가 필요하며, 이 과정은 실제 알고리즘 상에 나타나지 않는다.

② 32 비트형 변수 A₁, A₂, ...., A_k, Temp를 선언한다.

n개의 LFSR 값을 저장하기 위한 변수 A_i(1≤i≤k)와 새로운 값을 계산하여 저장할 템프(Temp)를 선언한다. 변수의 크기는 16, 32, 64 등이 모두 가능하나 현재 프로세서 환경과 사용되고 있는 LFSR의 차수를 고려할 때 32 비트형 변수를 사용하는 것이 가장 적절할 것으로 판단된다.

③ 32 비트형 변수 T₁, T₂,....., T_t-1를 선언한다.

하기의 단계 32를 알고리즘에 포함시킬 경우 필요한 t-1개의 임시변수를 선언한다.

단계 31: 초기값 설정

① 초기값으로 주어진 n개의 값 a₀, a₁,.....,a_n-1을 A₁, A₂,....., A_k에 저장한다.

A_k의 32개 메모리 중에서 가장 오른쪽에 a_n-1의 값이, 가장 왼쪽 메모리에 a_n-32의 값이 대입되도록 32개의 값을 A_k의 각각의 메모리에 순차적으로 대입한다.

비슷한 방법으로, A_k-1, A_k-2,....., A₁에 a_i들의 값을 순차적으로 대입한다.

② a₀의 값까지 대입하고 남은 A₁의 왼쪽 메모리 부분은 0으로 채운다.

단계 32: 임시 변수 T_j(1≤j≤t-1) 계산

① A₁, A₂,....., A_k를 메모리 시프트 연산과 비트별 배타적 논리합(XOR) 연산을 적절히 사용하여 T₁의 메모리 가장 왼쪽에 a_n1(=a₀)이, 가장 오른쪽에 a_n1+31(=a₃₁)이 순차적으로 저장되도록 한다. 이 과정은 2번의 메모리 시프트 연산과 1번의 배타적 논리합(XOR) 연산으로 해결할 수 있다.

② 비슷한 방법으로 A₁, A₂,....., A_k를 적절히 조합하여 T_j(≤j≤t-1)의 메모리 가장 왼쪽에 a_nj가, 가장 오른쪽에 a_nj+31이 순차적으로 저장되도록 한다.

단계 33: 템프(Temp) 계산

① 하기의 수학식 7을 이용하여 템프(Temp)를 계산한다.

② 템프(Temp)에는 새로운 32개의 LFSR 값들이 저장되게 된다. 상기 수학식 7에서 각각의 T_j(≤j≤t-1) 자리에 상기 단계 32의 T_j를 구하는 식을 직접 대입하면 상기 단계 32의 과정을 알고리즘에서 제외시킬 수 있다. 그 경우에는 연산 속도에는 영향이 없으나, 사용하는 메모리의 양을 감소시킬 수 있다.

단계 34: 변수 치환

① 새로운 LFSR 값들을 갱신하기 위하여 하기의 수학식 8과 같이 변수 치환을 한다.

단계 35: 상기 단계 34의 과정이 완료되면 새로운 LFSR 32 비트가 A_k에 생성되게 되고, 다음 32 비트를 생성하기 위한 초기값 설정까지 마치게 된다. m 비트의 출력을 원한다면회만큼 상기 단계 32 내지 단계 34까지의 과정을 반복 진행한다. 여기서, m은 출력비트 수를 나타낸다.

그러면 상기와 같이 이루어지는 알고리즘 3을 이용하여 LFSR의 소프트웨어를 구현하는 실시예를 설명하기로 한다.

원시 다항식에 의해서 생성되는 LFSR를 C 프로그램 언어로 구현한 소오스 코드는 다음과 같다. 이 경우 원시 다항식의 차수 n은 89,단수 t는 5가 되며, 따라서 상기 단계 30의 k값은이 된다.

#include <stdio.h>

void main()

{

int i, Print_Number;

unsigned long A1,A2,A3, Temp ; // 단계 30-②

unsigned long T1,T2,T3,T4 ; // 단계 30-③

A_1 = 0x01555555 ; // 단계 31-②

A_2 = 0x55555555 ; A_3 = 0x55555555 ; // 단계 31-①

Print_Number = 10000000 ; // 출력비트수 지정

Print_Number = Print_Number/32 + 1; // 반복문 횟수 지정

for(i = 0 ; i < Print_Number ; i++)

{

T1 = ( A1 << 7 ) ^ ( A2 >> 25 ) ; // 단계 32

T2 = ( A1 << 10 ) ^ ( A2 >> 22 ) ; // 단계 32

T3 = ( A2 << 21 ) ^ ( A3 >> 11 ) ; // 단계 32

T4 = ( A2 << 25 ) ^ ( A3 >> 7 ) ; // 단계 32

Temp = T1 ^ T2 ^ T3 ^ T4 ; // 단계 33

A1 = A2 ; A2 = A3 ; A3 = Temp ; // 단계 34

printf("%08x",A3) ; // 출력

}

상기와 같은 프로그램이 1회 수행될 경우, 변수 A1,A2,A3,T1,T2,T3,T4,Temp의 메모리에 저장되는 LFSR의 항들은 도 6과 같다. 편의상 도 6에서 a_i는 i로 표현했으며, A1의 "X" 부분은 실제의 데이터값이 0인 부분을 나타낸다.

다음으로, FCSR를 소프트웨어로 구현하기 위한 본 발명의 알고리즘을 설명하면 다음과 같다.

FCSR를 소프트웨어로 구현하기 위한 알고리즘은 상기한 LFSR를 소프트웨어로 구현하기 위한 알고리즘을 응용하여 실현하였다. 단, FCSR는 LFSR보다 생성원리가 복잡하기 때문에 일반적인 경우의 알고리즘은 구성할 수 없고, 약간의 제약을 가진 FCSR의 경우에만 적용이 가능하다.

FCSR를 생성하는 연결수도 LFSR의 원시 다항식처럼 차수와 단수를 비슷하게 정의할 수 있다. 연결수 q의 차수가 n이고 단수가 t라고 하자. 설명의 편의를 위하여 상기 수학식 3의 연결수를 계수가 0이 아닌 항의 합만으로 표현하면 하기의 수학식 9와 같이 된다.

따라서, 상기 수학식 4는 하기의 수학식 10과 같이 변형될 수 있다.

FCSR를 소프트웨어로 구현하기 위한 본 발명의 알고리즘은 상기 수학식 9에서 연결수 q의 단수가 11 이하이고, n₁이 32 이상인 경우에 대해서만 적용 가능하다. 실제 스트림 암호에서 FCSR가 사용될 때에는 10 정도의 단수를 가지는 100차 정도의 소수를 사용하고, 그 경우 n₁이 32 이상되는 소수는 많이 있으므로 상기한 제약 조건은 실용적인 관점에서 보았을 때 큰 문제가 되지 않는다.

이하에서는 상기한 조건을 만족하는 연결수에 의해 생성되는 FCSR의 새로운 소프트웨어 구현 알고리즘을 도 7의 흐름도를 참고하여 설명하기로 한다. 상기한 LFSR의 소프트웨어 구현 알고리즘에서 설명한 것과 중복되는 설명은 생략하기로 한다.

[알고리즘 4] FCSR를 소프트웨어로 구현하기 위한 본 발명의 알고리즘

단계 40: 변수 선언

①을 계산한다.

② 32 비트형 변수 A₁,A₂,.....,A_k,T₁,T₂,T₃,T₄,M을 선언한다.

n개의 FCSR 값을 저장하기 위한 변수 A_i(1≤i≤k)와 메모리값을 저장할 M, 그리고 부분적으로 새로운 값을 계산하여 저장할 임시 변수들을 선언하는 과정이다.

③ 32 비트형 변수 A₁₁,A₁₂,A_13,A_14,.....,A_k1,A_k2,A_k3,A_k4를 선언한다.

A_ij들은 하기의 단계 42에서 A_i에 저장된 값들을 분할하여 저장할 때 필요한 변수들이다.

단계 41: 초기값 설정

① 상기 LFSR의 소프트웨어 구현 알고리즘의 단계 31과 같은 방법으로 초기값을 설정한다.

② 초기값으로 주어진 메모리값 m을 M에 저장하고, M을 왼쪽으로 28번 메모리 시프트(memory shift)시킨다. 즉, M = ( M << 28 ).

단계 42: 변수 분할

① 초기변수 A_i(1≤i≤k)를 하기와 같은 연산을 시행하여 네 개의 변수 A_i1,A_i2,A_i3,A_i4로 분할한다.

- A_i1(A_i>> 3) 0x11111111

- A_i2(A_i>> 2) 0x11111111

- A_i3(A_i>> 1) 0x11111111

- A_i2(A_i) 0x11111111

여기서, 연산자 는 비트별 논리곱을 의미하고, ( B >> j )는 변수 B를 오른쪽으로 j 비트만큼 메모리 시프트하는 연산을 의미한다.

단계 42에서는 A_i에 저장되어 있는 32개의 초기값을 4개의 변수에 8개씩 분할하여 저장한다. 이때, 8개의 초기값은 32개의 메모리 공간 중 왼쪽으로부터 4, 8, 12, 16, 20, 24, 28, 32번째 위치에만 놓여지게 된다. 여기서는 이 위치의 비트들을 MSB( Most Significant Bit)라 한다.

변수 A₁에 a₀부터 a₃₁까지의 초기값이 저장되어 있다고 가정하고, A₁에 대하여 변수 분할을 하였을 때 각각의 변수에 저장되는 초기값들을 나타내면 도 8과 같다. 도 8에서는 수열 a_i를 i로 간단히 표기하였다.

단계 43: T₁, T₂, T₃, T₄계산

① 상기 단계 42에서 생성한 A_ij들을 이용하여, LFSR의 소프트웨어 구현 알고리즘의 단계 32와 비슷한 방법으로 T_1j(1≤j≤t-1)를 계산한다. 단, 이 경우에는 A_ij의 MSB들에만 실제 데이터들이 저장되어 있으므로, T_1j변수들도 중요 비트 8곳에만놓이도록 LFSR의 소프트웨어 구현 알고리즘의 단계 32를 약간 변형시켜 적용한다. 즉, LFSR의 경우 메모리의 가장 왼쪽 비트는 FCSR의 경우 '중요 비트' 8곳 중 가장 왼쪽을 의미하는 것으로 변형하여 적용시킨다.

② 상기 ①에서 생성한 T_1j(1≤j≤t-1)들을 정수 연산으로 더하여 T₁에 저장한다.

③ 상기 ①과 ②의 과정을 T₂, T₃, T₄에도 비슷하게 적용한다.

상기 ①의 과정은 메모리의 불필요한 낭비를 막기 위하여 실제 알고리즘 상에는 포함시키지 않고 상기 알고리즘 3의 단계 33에서 설명한 것과 같은 방법으로 상기 ②의 과정에 포함시킨다.

상기 ②의 과정에서, FCSR를 생성하는 연결수의 단수를 11 이하로 가정하였고, T_1j(1≤j≤t-1)에 저장되는 각 항이 차지하는 메모리 공간이 4 비트이기 때문에, '중요 비트'들 사이의 덧셈으로 인한 자리올림(Carry)은 다른 비트에 영향을 주지 않는다.

단계 43은 상기 수학식 4의 계산 과정 중에서 하기의 수학식 11까지를 계산해 T₁, T₂, T₃, T₄에 저장한 것이다.

단계 44:계산 및 M 값 갱신

FCSR의 새로운 항 a_k를 생성하려면, 바로 전 항에서 갱신되는 m_k-1을에 더해주어야 하는데, 이는 T₁, T₂, T₃, T₄변수들에 저장되어 있는 32개의 변수에 대해 순차적으로 진행한다. 이 과정을 표현하면 도 9와 같다. 도 9에서 연산기호(S1 내지 S4)는 모드(mod) 2³²의 정수 덧셈을, 기호 는 비트별 논리곱을 의미하며, C[j] ( 0 ≤ j ≤ 7) 값들은 하기의 수학식 12와 같이 표현된다.

C[j] = (0xe0000000) >> (j×4) , ( 0 ≤ j ≤ 7)

즉, C[0] = 0xe0000000 이고, C[7] = 0x0000000e 이다.

한편, j = 7 일 때는 {( C[j] ) >> 5} 연산은 의미에 맞도록 { ( C[j] ) << 27}로 변형시켜 적용한다.

상기 단계 44를 거치고 나면, T_i변수들에는 각각 4 비트 단위마다 상기 수학식 4의값이 저장되게 된다.

도 9의 알고리즘에서 M 값을 갱신하는 부분은, m_i의 값이의 값을 이진 전개했을 때 일차항의 계수가 된다는 점에 착안하여 구성한 것이다. 즉, 각각의값이 저장된 4 비트 메모리 중 오른쪽에서 두 번째 메모리의 값을 M 값으로 취한 것이다.

단계 45: 변수 치환 및 새로운 항 생성

새로운 32 비트 FCSR 값을 얻고, 다음 32 비트를 얻기 위하여 다음과 같이변수를 치환한다.

① A_i1=A_(i+1)1,A_i2=A_(i+1)2,A_i3=A_(i+1)3,A_i4=A_(i+1)4(1 ≤ i ≤ k-1)

② A_kj=T_j0x11111111 (1 ≤ j ≤ 4)

③ A_k=(A_k1≪ 3)(A_k2≪ 2)(A_k3≪ 1)(A_k4)

단계 46: 상기 단계 45의 과정이 종료되면 새로운 FCSR 32 비트가 A_k에 생성되게 되고, 다음 32 비트를 생성하기 위한 초기값 설정까지 마치게 된다. m 비트의 출력을 원한다면회만큼 상기 단계 43 내지 단계 45를 반복 실시한다.

그러면 상기와 같은 알고리즘 4를 이용하여 FCSR을 소프트웨어로 구현하는 실시예를 설명하기로 한다.

연결수 q=2⁸⁹+2⁸⁶+2⁴³+2³⁹-1에 의해서 생성되는 FCSR를 C 프로그램 언어로 구현한 소오스 코드는 다음과 같다.

#include <stdio.h>

void main()

{

int i,j, Print_Number;

unsigned long A1,A2,A3,T1,T2,T3,T4,M ; // 단계 40-②

unsigned long A11,A12,A13,A14,A21,A22,A23,A24

A31,A32,A33,A34 ; // 단계 40-③

unsigned long int K, C[8] ;

C[0] = 0xe0000000 ; // C[] : m 값을

C[1] = 0x0e000000 ; // update할 때 사용

C[2] = 0x00e00000 ; // 사용

C[3] = 0x000e0000 ;

C[4] = 0x0000e000 ;

C[5] = 0x00000e00 ;

C[6] = 0x000000e0 ;

C[7] = 0x0000000e ;

K = 0x11111111 ; // 변수분할에 사용

A_1 = 0x55555555 ; // 단계 41

A_2 = 0x55555555 ;

A_3 = 0x55555555 ;

M = 0x00000000 << 28 ;

Print_Number = 10000000 ; // 출력비트수 지정

Print_Number = Print_Number/32 + 1; // 반복문 횟수 지정

A11 = ( A1 >> 3 ) K ; A12 = ( A1 >> 2 ) K ; // 단계 42

A13 = ( A1 >> 1 ) K ; A14 = ( A1 ) K ; // 단계 42

A21 = ( A2 >> 3 ) K ; A22 = ( A2 >> 2 ) K ; // 단계 42

A23 = ( A2 >> 1 ) K ; A24 = ( A2 ) K ; // 단계 42

A31 = ( A3 >> 3 ) K ; A32 = ( A3 >> 2 ) K ; // 단계 42

A33 = ( A3 >> 1 ) K ; A34 = ( A3 ) K ; // 단계 42

for(i = 0 ; i < Print_Number ; i++)

{

T1 = (A14 << 4 )+(A24 >> 28) + (A13 << 8 )+(A23 >> 24) // 단계 43

+ (A22 << 20)+(A32 >> 12) + (A22 << 24)+(A32 >> 8 ) // 단계 43

T2 = (A11 << 8 )+(A21 >> 24) + (A14 << 8 )+(A24 >> 24) // 단계 43

+ (A23 << 20)+(A33 >> 12) + (A23 << 24)+(A33 >> 8 ) // 단계 43

T3 = (A12 << 8 )+(A22 >> 24) + (A11 << 12)+(A21 >> 20) // 단계 43

+ (A24 << 20)+(A34 >> 12) + (A24 << 24)+(A34 >> 8 ) // 단계 43

T4 = (A13 << 8 )+(A23 >> 24) + (A12 << 12)+(A22 >> 20) // 단계 43

+ (A22 << 24)+(A31 >> 8 ) + (A22 << 28)+(A31 >> 4 ) // 단계 43

for( j = 0 ; j < 7 ; j ++ )

{

T1 = T1 + M ; // 단계 44

M = ( T1 C[j] ) >> 1 ; // 단계 44

T2 = T2 + M ; // 단계 44

M = ( T2 C[j] ) >> 1 ; // 단계 44

T3 = T3 + M ; // 단계 44

M = ( T3 C[j] ) >> 1 ; // 단계 44

T4 = T4 + M ; // 단계 44

M = ( T4 C[j] ) >> 5 ; // 단계 44

}

T1 = T1 + M ; // 단계 44

M = ( T1 C[j] ) >> 1 ; // 단계 44

T2 = T2 + M ; // 단계 44

M = ( T2 C[j] ) >> 1 ; // 단계 44

T3 = T3 + M ; // 단계 44

M = ( T3 C[j] ) >> 1 ; // 단계 44

T4 = T4 + M ; // 단계 44

M = ( T4 C[j] ) << 27; // 단계 44

A11 = A21 ; A12 = A22 ; A13 = A23 ; A14 = A24 ; // 단계 45-①

A21 = A31 ; A22 = A32 ; A23 = A33 ; A24 = A34 ; // 단계 45-①

A31 = T1 K ; A32 = T2 K ; // 단계 45-②

A33 = T3 K ; A34 = T4 K ; // 단계 45-②

A3 = ( A31 << 3) ^ ( A32 << 2 ) ^ ( A33 << 1) ^ A34 ; // 단계 45-③

printf("%08x",A3) ; // 출력

}

상술한 바와 같이 본 발명은 불필요한 메모리의 낭비와 원시 다항식의 차수만큼 소요되었던 반복문의 횟수를 감소시킨다. 그러므로 종래의 FCSR 및 LFSR의 소프트웨어 구현 방식보다 30배 내지 300배 정도 빠른 알고리즘의 구현이 가능해지며, 알고리즘을 구현하는 데 필요한 메모리도 감소된다.

스트림 암호는 실제 대부분 응용환경에서 16 내지는 32 비트 단위로 전송되는데, 1 비트씩 생성되는 기존의 LFSR의 소프트웨어 구현 방식은 전송 단위만큼의 데이터가 만들어질 때까지 메모리에 저장되므로 이를 위한 별도의 저장 공간과 알고리즘을 필요로 했다. 그러나 본 발명의 알고리즘을 스트림 암호의 내부 논리로 사용하면 이러한 문제가 효과적으로 해결된다. 또한, 동일한 알고리즘을 하드웨어에 적용시킴으로써 하드웨어적으로도 고속 구현이 가능해진다.

Claims

변수의 갯수(k)를 계산한 후 n개의 LFSR 값을 저장하기 위한 변수와 새로운 값을 계산하여 저장할 템프를 선언하고 임시변수를 선언하는 제 1 단계와,

초기값으로 주어진 n개의 값을 상기 LFSR 값을 저장하기 위한 변수에 대입하여 저장한 후 남은 변수의 왼쪽 메모리 부분을 0으로 채우는 제 2 단계와,

상기 n개의 LFSR 값을 저장하기 위한 변수를 메모리 시프트 연산과 비트별 배타적 논리합 연산을 이용하여 임시변수의 메모리에 순차적으로 저장한 후 상기 n개의 LFSR 값을 저장하기 위한 변수를 조합하여 임시변수의 메모리에 순차적으로 저장하는 제 3 단계와,

n개의 LFSR 값을 저장하기 위한 템프를 계산하는 제 4 단계와,

새로운 LFSR 값들을 갱신하기 위하여 변수 치환을 실시하는 제 5 단계와,

원하는 비트의 출력을 얻을 때까지 상기 제 3 내지 제 5 단계의 과정을 반복 진행하는 제 6 단계를 포함하여 이루어지는 것을 특징으로 하는 시프트 레지스터의 소프트웨어 구현 방법.
제 1 항에 있어서,

상기 제 1 단계에서 상기 변수의 갯수(k)는 하기의 수학식 13에 의해 계산되는 것을 특징으로 하는 시프트 레지스터의 소프트웨어 구현 방법.
변수의 갯수(k)를 계산한 후 n개의 FCSR 값을 저장하기 위한 변수와 메모리 값을 저장할 메모리 변수 및 새로운 값을 계산하여 저장할 임시 변수들을 선언하고 상기 n개의 FCSR 값을 저장하기 위한 변수에 저장된 값들을 분할하여 저장할 때 필요한 변수를 선언하는 제 1 단계와,

초기값으로 주어진 n개의 값을 상기 n개의 FCSR 값을 저장하기 위한 변수에 대입하여 저장하고 남은 변수의 왼쪽 메모리 부분을 0으로 채운 다음 초기값으로 주어진 메모리값을 상기 메모리 변수에 저장하고 상기 메모리 변수를 왼쪽으로 메모리 시프트시키는 제 2 단계와,

초기변수에 저장된 초기값을 네 개의 변수로 분할하여 저장하는 제 3 단계와,

상기 제 3 단계에서 생성된 분할된 변수들을 이용하여 LFSR의 임시변수를 계산한 후 계산된 상기 임시변수를 정수연산으로 더하여 저장하는 제 4 단계와,

FCSR의 새로운 항을 생성하기 위하여 전 항에서 갱신된 메모리를 정수합에 더해주는 과정을 임시변수들에 저장된 변수에 대해 순차적으로 진행하는 제 5 단계와,

각각의 정수합이 저장된 메모리 중 오른 쪽에서 두번째의 값을 메모리 값으로 갱신하는 제 6 단계와,

새로운 32 비트 FCSR 값을 얻고난 후 다음 32 비트를 얻기 위하여 변수를 치환하는 제 7 단계와,

원하는 비트의 출력을 얻을 때까지 상기 제 4 단계 및 제 7 단계의 과정을 반복 실시하는 제 8 단계를 포함하여 이루어지는 것을 특징으로 하는 시프트 레지스터의 소프트웨어 구현 방법.
제 3 항에 있어서,

상기 제 1 단계에서 상기 변수의 갯수(k)는 하기의 수학식 14에 의해 계산되는 것을 특징으로 하는 시프트 레지스터의 소프트웨어 구현 방법.
제 3 항에 있어서,

상기 제 3 단계에서 상기 변수의 분할은 하기와 같이 이루어지는 것을 특징으로 하는 시프트 레지스터의 소프트웨어 구현 방법.

① A_i1(A_i>> 3) 0x11111111

② A_i2(A_i>> 2) 0x11111111

③ A_i3(A_i>> 1) 0x11111111

④ A_i2(A_i) 0x11111111
제 3 항에 있어서,

상기 제 7 단계의 변수 치환은 하기와 같이 이루어지는 것을 특징으로 하는 시프트 레지스터의 소프트웨어 구현 방법.

① A_i1=A_(i+1)1,A_i2=A_(i+1)2,A_i3=A_(i+1)3,A_i4=A_(i+1)4(1 ≤ i ≤ k-1)

② A_kj=T_j0x11111111 (1 ≤ j ≤ 4)

③ A_k=(A_k1≪ 3)(A_k2≪ 2)(A_k3≪ 1)(A_k4)