1. Introduction to the algorithm

The A5/1 encryption algorithm is used for data confidentiality encryption in GSM. This algorithm uses three linear feedback shift registers, denoted as X, Y, and Z. Where X(x₀, x₁, …, x₁₈) The register has 19 bits, the Y register has 22 bits, and the Z register has 23 bits. The following does not explain the principle, only the key stream generation algorithm.

1. Define the X operation:
     temp = x₁₃ ^ x₁₆ ^ x₁₇ ^ x₁₈
     x_i = x_i-1 for i = 18, 17, 16, …, 1
     x₀ = temp; (In short, it is shifted one bit to the left, and then the first bit uses the x before shifting left₁₃ ^ x₁₆ ^ x₁₇ ^ x₁₈Filling, similar to the following)
   Define Y operation:
     temp = y₂₀ ^ y₂₁
     y_i = y_i-1 for i = 21, 20, 19, …, 1
     y₀ = temp;
   Define Z operation:
     temp = z₇ ^ z₂₀ ^ z₂₁ ^ z₂₂
     z_i = z_i-1 for i = 22, 21, 20, …, 1
     z₀ = temp;
2. Define the majority voting function maj(x, y, z): If the number of 0 in x, y, z is more, return 0; otherwise, return 1.
3. Let m = maj(x₈, y₁₀, z₁₀), if x₈ = m, then perform X operation; if y₁₀ = m, then perform Y operation; if z₁₀ = m, then perform the Z operation.
4. Keystream bits s = x₁₈ ^ y₂₁ ^ z₂₂。
5. Repeat the above steps to generate the key stream.

2. Simple implementation

A simple realization with C++, put a main.cpp text file encryption and decryption in the same directory of the code.

#include <cstdio>
#include <iostream>
#include <cstdlib>
#define _for(i,a,b) for(int i=(a); i<(b); ++i)
#define setbit(x,y)  x|=(1<<y)  
#define clrbit(x,y)  x&=~(1<<y) 
#define reversebit(x,y)  x^=(1<<y)
#define getbit(x,y)   (x&=(1<<y)) 
using namespace std;
typedef unsigned char uc;
bool x[19] = {1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1};
bool y[22] = {1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0,1,1};
bool z[23] = {1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0};
int maj(bool x, bool y, bool z) {
	return x + y + z >= 2;
}
void X(bool x[]) {
	bool temp = x[13] ^ x[16] ^ x[17] ^ x[18];
	for(int i = 18; i >= 1; i--) {
		x[i] = x[i-1];
	}
	x[0] = temp;
}
void Y(bool y[]) {
	bool temp = y[20] ^ y[21];
	for(int i = 21; i >= 1; i--) {
		y[i] = y[i-1];
	}
	y[0] = temp;
}
void Z(bool z[]) {
	bool temp = z[7] ^ z[20] ^ z[21] ^ z[22];
	for(int i = 22; i >= 1; i--) {
		z[i] = z[i-1];
	}
	z[0] = temp;
}
uc* generateSecretKeyStream(int n) {
	bool temp[8]; 
	uc* secretKeyStream = (uc*)malloc(n/8 + 1);
	int cnt = 0, cnt1 = 0;
	_for(i, 0, n) {
		bool m = maj(x[8], y[10], z[10]);
		if(x[8] == m) {
			X(x);
		}
		if(y[10] == m) {
			Y(y);
		}
		if(z[10] == m) {
			Z(z);
		}
		bool s = x[18] ^ y[21] ^ z[22];
		temp[cnt++] = s;
		if(cnt == 8) {
			_for(j, 0, cnt) {
				if(temp[j] == 0) {
					clrbit(secretKeyStream[cnt1], j);
				} else {
					setbit(secretKeyStream[cnt1], j);
				}
			}
			cnt1++;
			cnt = 0;
		}
	}
	_for(j, 0, cnt) {
		if(temp[j] == 0) {
			clrbit(secretKeyStream[cnt1], j);
		} else {
			setbit(secretKeyStream[cnt1], j);
		}
	}
	return secretKeyStream;
}
int getFileSize(FILE *fp) {
	fseek(fp, 0L, SEEK_END);
    int size = ftell(fp);
    fseek(fp, 0L, 0);
    return size;
} 
uc* readFromFile(FILE *fp, int size) {
	uc *buffer = (uc *)malloc(sizeof(uc) * size);
	fread(buffer, size, 1, fp);
	return buffer;
}
int main(int argc, char const **argv) {
	FILE* fp = fopen("main.cpp", "r");
	if(!fp) {
		return -1;
	}
	int fileSize = getFileSize(fp);
    uc *buffer = readFromFile(fp, fileSize);
    uc* secretKeyStream = generateSecretKeyStream(fileSize * 8);
    _for(i, 0, fileSize) {
    	buffer[i] ^= secretKeyStream[i];
	}
	FILE* fp1 = fopen("secret.a51", "w");
	fwrite(buffer, fileSize, 1, fp1);
	_for(i, 0, fileSize) {
    	buffer[i] ^= secretKeyStream[i];
	}
	FILE* fp2 = fopen("_secret.a51", "w");
	fwrite(buffer, fileSize, 1, fp2);
	fclose(fp);
	fclose(fp1);
	fclose(fp2);
	free(buffer);
	return 0;
}